How do I reduce CDE latency?

Choose workspace regions close to developers, use CDN for static assets, enable compression on SSH connections, consider file sync tools like Mutagen for large projects, and ensure adequate network bandwidth.

How do I speed up builds in CDEs?

Implement build caching (Docker layer cache, npm/pip cache, ccache for C++), use remote build caches like Gradle Enterprise or Nx Cloud, pre-warm workspaces with dependencies, and allocate sufficient CPU/memory for build tasks.

When should I use file synchronization with CDEs?

Use file sync (Mutagen, rsync) when: working with very large codebases, experiencing noticeable file operation latency, needing offline access to some files, or when IDE file watching is slow. Most projects work fine without it.

CDE Performance - Latency, Caching & File Sync

Network Latency Mitigation

Optimize remote connections for responsive development

<50ms

Excellent - local feel

50-100ms

Good - acceptable

100-150ms

Noticeable lag

>150ms

Needs optimization

WireGuard VPN Optimization

WireGuard provides 20-30% lower latency than traditional VPNs due to its modern cryptographic design.

# /etc/wireguard/wg0.conf (CDE server)
[Interface]
PrivateKey = SERVER_PRIVATE_KEY
Address = 10.200.200.1/24
ListenPort = 51820
PostUp = iptables -A FORWARD -i %i -j ACCEPT
PostDown = iptables -D FORWARD -i %i -j ACCEPT

# MTU optimization for low latency
MTU = 1420

[Peer]
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.200.200.2/32
PersistentKeepalive = 25

Tip: Tailscale provides managed WireGuard with automatic NAT traversal - ideal for distributed teams.

SSH Performance Tuning

# ~/.ssh/config optimizations
Host cde-*
    # Use faster cipher
    Ciphers [email protected],[email protected]

    # Enable compression (helps on slow networks)
    Compression yes

    # Reuse connections (huge latency win)
    ControlMaster auto
    ControlPath ~/.ssh/sockets/%r@%h-%p
    ControlPersist 600

    # TCP keepalive
    TCPKeepAlive yes
    ServerAliveInterval 15
    ServerAliveCountMax 3

    # Forward agent for git operations
    ForwardAgent yes

    # Disable unnecessary features
    VisualHostKey no
    UpdateHostKeys no

Multi-Region Deployment Strategy

Developer Location	Recommended Region	Expected Latency	Cloud Provider
US East Coast	us-east-1 / eastus / us-east1	20-40ms	AWS / Azure / GCP
US West Coast	us-west-2 / westus2 / us-west1	20-40ms	AWS / Azure / GCP
Western Europe	eu-west-1 / westeurope / europe-west1	30-50ms	AWS / Azure / GCP
Asia Pacific	ap-southeast-1 / southeastasia / asia-southeast1	40-70ms	AWS / Azure / GCP

Build Caching Strategies

Reduce build times with smart caching at every layer

Docker Layer Caching

Bad: No Layer Reuse

# Dockerfile - Bad Pattern
FROM node:18
WORKDIR /app
COPY . .                     # Invalidates on ANY change
RUN npm install              # Re-runs every time
RUN npm run build

Good: Maximized Layer Reuse

# Dockerfile - Good Pattern
FROM node:18
WORKDIR /app
COPY package*.json ./        # Only deps files first
RUN npm ci --cache /tmp/.npm # Cache npm downloads
COPY . .                     # App code last
RUN npm run build

npm/pnpm

# devcontainer.json
"mounts": [
  "source=node-modules-cache,target=/workspaces/node_modules,type=volume"
]

pip

# Cache pip downloads
ENV PIP_CACHE_DIR=/pip-cache
RUN --mount=type=cache,target=/pip-cache \
    pip install -r requirements.txt

Go

# Persistent Go module cache
ENV GOMODCACHE=/go-cache
RUN --mount=type=cache,target=/go-cache \
    go mod download

Cargo

# Cargo build cache
ENV CARGO_HOME=/cargo-cache
RUN --mount=type=cache,target=/cargo-cache \
    cargo build --release

Remote Build Cache (Team Sharing)

Turborepo (JavaScript/TypeScript)

# turbo.json
{
  "$schema": "https://turbo.build/schema.json",
  "remoteCache": {
    "signature": true,
    "preflight": false
  }
}

# Enable remote cache
npx turbo login
npx turbo link

Gradle Build Cache

// settings.gradle.kts
buildCache {
    remote {
        url = uri("https://cache.company.com/cache/")
        isPush = true
        credentials {
            username = "build-user"
            password = System.getenv("CACHE_PASSWORD")
        }
    }
}

File Synchronization

Bidirectional file sync for responsive editing

Mutagen File Synchronization

Mutagen provides high-performance bidirectional sync, perfect for keeping local and remote files in sync during high-latency connections.

# Install Mutagen
brew install mutagen-io/mutagen/mutagen  # macOS
# or download from mutagen.io

# Create sync session
mutagen sync create \
  --name=cde-sync \
  --ignore=node_modules \
  --ignore=.git \
  --ignore=vendor \
  --ignore=target \
  ~/local-project \
  developer@cde-server:~/projects/app

# Monitor sync status
mutagen sync list
mutagen sync monitor cde-sync

# Configuration file (mutagen.yml)
sync:
  app:
    alpha: "~/local-project"
    beta: "developer@cde-server:~/projects/app"
    mode: "two-way-resolved"
    ignore:
      vcs: true
      paths:
        - "node_modules/"
        - ".cache/"
        - "dist/"

Two-Way Sync

Changes propagate both directions

Sub-Second

Changes sync in <100ms typically

Conflict Resolution

Automatic handling of edit conflicts

Resource & IDE Tuning

Optimize CPU, memory, and IDE settings for peak performance

VS Code Performance Settings

{
  // Reduce memory usage
  "files.maxMemoryForLargeFilesMB": 512,
  "typescript.tsserver.maxTsServerMemory": 3072,

  // Disable heavy features
  "editor.minimap.enabled": false,
  "breadcrumbs.enabled": false,
  "editor.renderWhitespace": "none",

  // Optimize file watching
  "files.watcherExclude": {
    "**/node_modules/**": true,
    "**/.git/objects/**": true,
    "**/dist/**": true,
    "**/build/**": true,
    "**/.cache/**": true
  },

  // Reduce extension load
  "extensions.autoUpdate": false,
  "telemetry.telemetryLevel": "off",

  // Search optimization
  "search.followSymlinks": false,
  "search.useGlobalIgnoreFiles": true
}

Workspace Resource Allocation

# Kubernetes workspace resources
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: workspace
    resources:
      requests:
        cpu: "2"           # Guaranteed CPU
        memory: "4Gi"      # Guaranteed memory
      limits:
        cpu: "4"           # Burstable to 4 cores
        memory: "8Gi"      # Max memory

# Coder template resource config
resource "coder_agent" "main" {
  metadata {
    key = "cpu"
    value = data.coder_parameter.cpu.value
  }
}

data "coder_parameter" "cpu" {
  name = "CPU Cores"
  default = "4"
  mutable = true
  option { name = "2 cores" value = "2" }
  option { name = "4 cores" value = "4" }
  option { name = "8 cores" value = "8" }
}

Continue Optimizing

Related performance resources

Performance Optimization