Local Dev Environments: Docker, Local, DevKinsta Compared

Editing a live site directly works until the day it doesn't. A local environment, a copy of the site running on your own computer, is where updates get tested, themes get built and mistakes stay private.

For WordPress work, three routes cover most needs: Local, DevKinsta, and Docker used directly. All three are free to start with, and all three will run a site. They differ in how much they hide from you, and that difference decides which one fits.

The short version

LocalDevKinstaDocker (wp-env, DDEV, Compose)
Made byWP EngineKinstaOpen-source tools on top of Docker
How it runsNative services on your machineDocker containers behind a desktop appDocker containers you configure yourself
InterfaceDesktop appDesktop appCommand line and config files
Beyond WordPressNoNoYes: Drupal, Laravel, Node and more
Deploy integrationWP Engine and FlywheelKinstaNone built in; any host via your own workflow
Setup shared through GitNoNoYes
Best forGetting a WordPress site running in minutesSites hosted on KinstaTeams, mixed stacks and production parity

Local: the fastest way to a working site

Local is a desktop app for macOS, Windows and Linux. Click to create a site, choose a name, and WordPress is running a minute or so later. It doesn't use Docker. PHP, MySQL and the web server run as native services, which keeps it comparatively light.

What it does well:

  • Per-site settings without config files. PHP version and web server (nginx or Apache) can be switched for each site from the interface.
  • The usual developer tools are built in. One-click HTTPS, WP-CLI through a site shell, Xdebug, log access and a mail catcher that stops test emails leaving your machine.
  • Blueprints. A configured site, with your starter theme and standard plugins, can be saved as a template and reused.
  • Live Links. A temporary public URL lets a client see work in progress. This needs a free Local account.

Where it falls short:

  • WordPress only. A Drupal or Laravel project needs a different tool.
  • The setup lives in the app, not in the project. A colleague can't clone your repository and get the same environment. They have to rebuild it by hand or import an export.
  • Push and pull only cover WP Engine and Flywheel. For any other host, deployment is manual or handled by a migration plugin.

DevKinsta: the natural choice for Kinsta sites

DevKinsta is Kinsta's free desktop app. It looks similar to Local but is built differently: every site runs in Docker containers, so Docker Desktop has to be installed and running first. DevKinsta will offer to install it for you.

What it does well:

  • Kinsta integration. Sites can be pulled from Kinsta and pushed back to a staging environment from the app. If your sites are hosted there, this is the main reason to choose it.
  • A stack close to Kinsta's. Sites run on Nginx with a selectable PHP version, which reduces "works locally, breaks on staging" surprises for Kinsta customers.
  • Built-in helpers. A database manager, a local email inbox and a toggle for WP_DEBUG.

Where it falls short:

  • Docker's overhead without Docker's flexibility. You carry the memory and disk cost of containers (Kinsta lists 5 GB of disk and 2 GB of RAM as the minimum), but the containers are managed by the app and not designed to be customised.
  • WordPress only, Nginx only. A site that depends on Apache behaviour or .htaccess rules won't be mirrored faithfully.
  • Little benefit outside Kinsta. Without the push and pull workflow, Local does the same job with less weight.

Docker: more setup, more control

Docker runs each service (web server, PHP, database) in an isolated container defined by a configuration file. That file is the point. It lives in the project's repository, so anyone who clones the project gets the same environment with one command.

Few people write that configuration from scratch any more. Two tools do most of the work.

wp-env

wp-env is the WordPress project's own tool, aimed at plugin and theme development. With Docker and Node.js installed:

npm -g install @wordpress/env
cd my-plugin
wp-env start

WordPress is then available at http://localhost:8888 with the plugin or theme in the current folder already active. A small .wp-env.json file pins the details:

{
  "core": "WordPress/WordPress",
  "phpVersion": "8.3",
  "plugins": [ "." ]
}

DDEV

DDEV is an open-source tool for full sites, and it isn't limited to WordPress. The same commands run Drupal, Laravel and other PHP or Node projects, which matters if your client list is mixed.

ddev config --project-type=wordpress
ddev start
ddev launch

DDEV writes its settings to a .ddev folder that is committed with the project. PHP version, database version and web server are set there, so they can be matched to the production server.

What the Docker route does well:

  • Reproducibility. The environment is defined in the repository, not in someone's memory.
  • Production parity. Versions can be pinned to match the live server exactly.
  • One tool for every stack.

Where it falls short:

  • A real learning curve. You need to be comfortable in a terminal and willing to read an error message.
  • Resource use. Docker Desktop reserves memory whether or not a site is busy, and file access can be slower than native on macOS and Windows.
  • Licensing at scale. Docker Desktop is free for personal use and for businesses with fewer than 250 employees and under $10 million in annual revenue. Larger organisations need a paid subscription. DDEV also works with alternative Docker providers such as OrbStack, Colima or Rancher Desktop.

How to choose

Feature lists make these tools look more alike than they are. Two questions separate them: where will the site be hosted, and does anyone else need to run it?

Choose the environment for where the site will live and who else has to run it, not for its feature list.

  • You work alone on WordPress sites across various hosts. Local. It is the least effort for the most result.
  • Your sites are on Kinsta. DevKinsta, for the staging workflow.
  • Your sites are on WP Engine or Flywheel. Local, for the same reason.
  • You build plugins or themes. wp-env, since it is what WordPress core development itself uses.
  • You work in a team, or with more than one CMS. DDEV. The setup travels with the project.
  • You must match a specific server configuration. Docker in some form. The desktop apps only approximate it.

One newer option deserves a mention. Studio, from WordPress.com, runs WordPress without Docker or a separate database server, which makes it very light. It suits quick tests and demos more than work that has to mirror a production server.

Whichever tool you pick

  • Match the PHP version to production. It is the most common cause of code that works locally and fails live.
  • Keep code in Git, not in the tool. The environment should be disposable. If deleting it would lose work, something is wrong.
  • Treat copied databases as sensitive. A local copy of a live site contains real customer data. Anonymise it or keep it encrypted, and delete it when the job is done.
  • Check that email is caught. All of these tools intercept outgoing mail by default. Confirm it before testing anything that notifies customers.
  • Don't run two at once without reason. Local, DevKinsta and Docker tools compete for the same ports, and the resulting errors are confusing.

In short

Local is the quickest path to a working WordPress site. DevKinsta is the same idea tuned for Kinsta hosting. Docker, through wp-env or DDEV, costs more effort up front and repays it when a project has to be shared, matched to a server or kept running for years.

None of them is the best in general. Choose for where the site will live and who else has to run it.

Changed