Dev Environments

Production-grade environments. Ready in seconds.

Your team wastes days on environment setup. Now they don't have to anymore.

The setup problem is half-solved

Most development teams have made progress with containerization. Many use Docker Compose, devcontainers, or setup scripts. However, the remaining challenge isn't complete failure — it's fragility. Docker builds take extended periods with cache invalidation issues. Devcontainers work inconsistently across different machines. Documentation becomes outdated quickly after infrastructure changes. Individual developers experience divergence across their machines.

Key Statistic: "156 hours per year per developer spent on environment setup and maintenance" (Microsoft Dev Box case study)

This represents nearly four full work weeks annually per person spent on infrastructure rather than product work.

The golden image

The solution involves moving from configuration recipes to running systems. Teams should configure a single machine with the complete stack — Docker containers, databases, services, tools, configurations. This becomes the golden image that developers fork.

$ ssh boxd.sh fork production-stack --name=sarah
forked production-stack → sarah (sarah.boxd.sh)

$ ssh boxd.sh connect sarah
boxd@sarah:~$ docker ps
CONTAINER ID   IMAGE          STATUS       NAMES
a1b2c3d4e5f6   myapp/web       Up 2 hours   app-web
f6a1b2c3d4e5   myapp/api       Up 2 hours   app-api
c3d4e5f6a1b2   postgres:14     Up 2 hours   postgres
d4e5f6a1b2c3   redis:7         Up 2 hours   redis
e5f6a1b2c3d4   nginx:latest    Up 2 hours   nginx

Developers receive fully configured, running environments in seconds rather than blank VMs or lengthy build processes. The platform team maintains the golden image. Updates propagate automatically to all forked instances.

Free yourself of dependency drift

Environment drift stems from structural factors, not people problems. Development machines accumulate changes over time. Traditional scripted setups suffer the same degradation — "script drift" replaces environment drift.

CI exacerbates this issue. CI runners represent fundamentally different runtime environments than development machines, with different filesystems, kernels, resource constraints, and state management. Docker narrows but doesn't eliminate these gaps.

When developers fork identical machine images, drift becomes structurally impossible. Forks maintain identical OS versions, packages, running services, and file paths. Only developer code changes afterward. This approach rules out environment differences by construction.

Shareable by default

Every boxd machine includes a public HTTPS URL upon startup. Developers can share URLs with colleagues or fork entire machines for others to examine.

$ ssh boxd.sh list
name              status     url                              image
sarah             running    sarah.boxd.sh                 default
mark              running    mark.boxd.sh                  default
staging           running    staging.boxd.sh               default

$ ssh boxd.sh fork sarah --name=sarah-demo
forked sarah → sarah-demo (sarah-demo.boxd.sh)

This eliminates gaps between development and visibility. Designers see actual running applications rather than screenshots. Product managers test features pre-merge. Backend engineers debug integration issues using real services.

Try things without fear

Developers typically approach environment changes cautiously because failures require extensive recovery time. When forking takes seconds, experimentation becomes cost-free.

$ ssh boxd.sh fork sarah --name=try-nextjs-15
forked sarah → try-nextjs-15 (try-nextjs-15.boxd.sh)

$ ssh boxd.sh connect try-nextjs-15
boxd@try-nextjs-15:~$ npm install next@15
... breaks three things

boxd@try-nextjs-15:~$ exit
$ ssh boxd.sh destroy try-nextjs-15
destroyed try-nextjs-15

Failed experiments involve minimal time loss. Original environments remain untouched. This encourages rapid testing rather than extensive research.

Persistent

Machines persist across sessions. Developers closing laptops Friday retrieve running services Monday morning without rebuilds or reinitializations.

# Friday, 6pm
boxd@sarah:~$ exit

# Monday, 9am
$ ssh boxd.sh connect sarah
boxd@sarah:~$ docker ps
CONTAINER ID   IMAGE          STATUS         NAMES
a1b2c3d4e5f6   myapp/web       Up 3 days      app-web
f6a1b2c3d4e5   myapp/api       Up 3 days      app-api
c3d4e5f6a1b2   postgres:14     Up 3 days      postgres
d4e5f6a1b2c3   redis:7         Up 3 days      redis

Machines sleep when idle without cost. Reconnection takes seconds rather than minutes. No morning infrastructure startup rituals are necessary.

Work from anywhere

Environments live in the cloud rather than on individual hardware. Developers SSH from laptops, tablets, borrowed computers, or multiple offices. Single environment synchronization becomes unnecessary. Hardware specifications stop limiting developer capabilities. Three-year-old laptops provide equivalent performance to latest models.

Configure once, fork forever

Golden images apply production infrastructure patterns to development. The approach mirrors immutable infrastructure practices used in production — configure once, fork repeatedly.

Onboarding Example:

$ ssh boxd.sh fork production-stack --name=new-hire-day-1
forked production-stack → new-hire-day-1 (new-hire-day-1.boxd.sh)

New hires begin writing code on day one with production-grade environments matching the entire team. Setup overhead approaches zero.