# Contents

We've all heard the dreaded "works on my machine" excuse from developers when something breaks in staging or production. This happens because developers often use different setups and configurations locally than what is used in other environments. These inconsistencies waste time debugging issues that only appear outside development and result in defects reaching users.

Standardized development environments (SDEs) can prevent these problems by ensuring everyone codes using identical infrastructure and configurations. SDEs greatly boost productivity, code quality, and velocity by bridging local development and deployment gaps.

Why "It Works on My Machine" Happens

Historically, development and production environments were entirely separate domains. Developers worked exclusively locally, while ops teams handled deployment and runtime.

Developers naturally optimize their local configurations for moving fast, experimenting, and iteratively coding features. They install new SDKs, tools, and dependencies without worrying about broader compatibility.

Over months and years of work, the gap between these developer-optimized environments and production environments grows. New libraries get added, dependencies and settings drift, and inconsistencies creep in.

When a problem arises only for customers or testers, it becomes difficult or impossible to reproduce precisely in the development environment. The code may technically function in development, leading to the claim that "it works on my machine."

The High Costs of Environment Inconsistencies

Having development and testing environments that differ significantly from production imposes multiple forms of waste on engineering teams:

  • Context switching: When developers need to switch between local configs and production constantly, it breaks their flow and slows them down.

  • Hidden defects: Bugs that only manifest due to inconsistencies waste huge amounts of time debugging in staging and production.

  • Customer experience: Defects that slip through the cracks severely degrade user experiences and damage your brand.

  • Delayed issue resolution: The inability to reproduce problems makes pinpointing root causes and developing fixes hard.

While some divergence across environments is inevitable, teams shouldn't accept it as normal. The costs of configuration inconsistencies are simply too high.

The Role of Automation and Standards

Automation and standardization are key enablers of environment unification:

  • Provisioning automation: Automated provisioning, deployment, and restarts ensure consistency.

  • Policy frameworks: Organization-wide configuration and management policies reduce drift.

  • Development standards: Coding standards produce portable applications resilient to environment changes.

  • Templatized resources: Template schemas for databases, infrastructure, and environment (e.g. devcontainer.json), etc., provide unified building blocks.

  • Self-service platforms: Platform teams build self-service access to provisioned unified environments.

Heavy reliance on manual processes is incompatible with managing unified environments at scale.

How SDEs Solve These Problems

Standardized development environments (SDEs) solve these problems by providing identical infrastructure from development through production:

  • Unified configurations - Everyone works using real production settings

  • Simultaneous rollout - Changes deploy simultaneously across all environments

  • Rapid reproducibility - Production issues can be quickly reproduced and debugged locally

  • Improved debugging - All environments share a common platform for tracing issues

By standardizing the entire technology stack, SDEs unite traditionally disconnected environments. This prevents issues arising from configuration drift across environments.

Transitioning to SDEs

Adopting SDEs can have its challenges, including migrating legacy systems, organizational silos, performance impacts, and security considerations.

Incremental change management and utilizing techniques like:

  • Containerized services: Containers allow packing apps and dependencies identically for deployment to any environment.

  • Infrastructure-as-code: Central source repositories for infrastructure definitions and automation code keep environments in sync.

  • Dynamic provisioning: Programmatically spinning up preconfigured environments ensures consistency and optimization.

The right combination of techniques depends on your tech stack and existing resources. The key is infrastructure consistency.

The automation and self-service access SDE platforms make managing environments efficiently at scale much easier.

Realizing the Benefits of SDEs

While attaining completely identical environments is difficult, getting closer unlocks huge gains. SDEs enable code checked in today to be deployable tomorrow with confidence.

By standardizing infrastructure and configurations using SDEs, teams gain faster innovation, higher-quality apps, and happier developers. The "works on my machine" excuse becomes a relic of the past.


The infamous "works on my machine" stems from gaps between the environments used by developers, testers, and IT operations teams. Running everyone on a shared fleet of managed resources powered by standardization, automation, and cloud infrastructure can unify these worlds. SDEs can eradicate issues caused by configuration inconsistencies through unified infrastructure automation.

This shift requires overcoming legacy inertia and organizational silos. However, the payoff in developer productivity, security, software quality, and business agility makes investing in environment standardization worthwhile. Eliminating configuration inconsistencies should be a priority for any high-performance software organization.

Despite requiring legacy system migrations and organizational change, the productivity and velocity improvements SDEs unlock make investing in standardization a priority. Eliminating the "works on my machine" phenomenon is essential for any high-performance engineering organization.