Buyer’s Guide

Best Developer Onboarding Tools

Written by Govind Kumar Lohar. Reviewed for technical accuracy by Deepak Gupta and Bhaskar Suthar on · Review panel

  • onboarding
  • devex
  • developer-tools
  • platform-engineering

Independent buyer’s guide. No vendor paid to be included, ranked or described a particular way. Written for engineers, architects and the people who sign off on their tooling budget. Editorial policy.

Most onboarding programmes measure the wrong things. Checklists completed. Documents read. Sessions attended. A buddy assigned. All of it is process that feels like progress and none of it tells you whether the new engineer can actually change the system.

There is one measurement that does, and it is uncomfortable precisely because it cannot be gamed: how long from a new engineer’s first day to their first pull request merged into the default branch. Not written, not opened, merged. It compresses everything that matters into a single number, because a merged pull request requires a working environment, enough orientation to find the right file, credentials to run the tests, permission to push a branch, and a reviewer who knew the change was coming.

The number is also diagnostic. A team where it is two days and a team where it is three weeks are not differently talented. They have different amounts of undocumented setup, different access request queues, and different amounts of tribal knowledge that never got written down. The gap is almost entirely mechanical, and mechanical problems have tools.

What follows is organised around that metric: what actually consumes the days, and which tools remove which part. Be warned that the tool with the largest effect is the least exciting one on the list.

Key takeaways

  • Time to first merged pull request is the only onboarding metric worth tracking, because it cannot be satisfied by anything except an engineer who can genuinely ship a change.
  • The time is consumed by three things: environment setup, codebase orientation and access provisioning. Most teams optimise the first, which is usually not the largest.
  • Access provisioning is frequently the biggest single block and the least discussed, because the delay lives in another team’s queue and never appears in an engineering retrospective.
  • A maintained repository README that is actually correct beats every product in this category. The reason teams buy tools instead is that fixing the README requires someone to own it.

Time to first merged pull request

Define it precisely before measuring it, because the ambiguity is where the metric goes soft.

Start the clock at the engineer’s first working day, not at their offer acceptance or their laptop arrival. End it when a pull request authored by them merges into the default branch of a repository the team owns. Exclude nothing: not documentation-only changes, not a one-line fix, not a change they pair-programmed. If they authored it and it merged, it counts.

People object that this rewards trivial first changes. It does, and that is correct. A trivial first change that merges proves the entire pipeline works end to end: environment, credentials, tests, review, CI, deploy permissions. It is a smoke test for your onboarding, and finding the broken step on day two with a one-line change is far better than finding it on day fifteen inside a real feature.

The counter-practice worth adopting is deliberate: give every new engineer a genuinely small, genuinely real first task, chosen in advance, and treat any obstacle they hit as a defect in the onboarding rather than a question for them. The obstacles they hit are the map. Have them write down every one, and fix the top three before the next hire.

What the metric hides, and what you should track alongside it, is how much of the time was the new engineer working versus waiting. Two weeks spent reading a complex domain is different from two weeks spent waiting for a production database credential. The first is education and the second is a defect.

Needs first-hand data: For the last ten engineers who joined, reconstruct three timestamps each: first day, environment able to run the test suite, first merge. Then ask each of them which single obstacle cost the most time. The distribution of those answers, not the averages, tells you which of the three categories below to fix first, and it is rarely the one the team assumes.

The three things that consume the time

Environment setup. Getting a machine to the point where the code builds, the tests pass and the application runs locally. This is the part with the most tooling and the most attention, because it is the part engineers control.

The specific failures are consistent. A README written when the project started and silently wrong since. A required system dependency that everyone already has installed and nobody remembers installing. A version manager that pins the language version but not the database version, the message broker version or the native library the package depends on. Credentials needed just to install dependencies from a private registry. And the platform split, where the setup instructions were written on one operating system and the new engineer is on another.

The fix is to make the environment a build artefact rather than a sequence of instructions. If the environment is defined as a file in the repository and constructed by a command, it is versioned, reviewed and repaired for everyone at once when it breaks. If it is a wiki page, it is wrong.

Codebase orientation. Knowing where things live, which service owns which concern, what the request path is, which of three similar modules is the live one, and which patterns in the codebase are current versus abandoned.

This consumes more calendar time than setup and gets far less tooling attention, because it feels like something that only time can fix. Partly it is. But a large share of it is mechanical: an accurate service catalogue answers ownership questions instantly, good code search answers “where is this handled” in seconds, and an architecture document that is correct saves days of reverse engineering. The parts that tooling cannot fix are the parts about why, which is exactly where a human mentor is irreplaceable and should be spending their time rather than explaining directory layout.

Access provisioning. Source control, CI, cloud consoles, the error tracker, the observability platform, the secret store, the staging database, the design tool, the incident channel. Each is a request, each request has a queue, and the queues are in other teams.

This is the category that most often dominates and least often gets attributed, because the waiting happens in a system nobody in engineering looks at. It is also the easiest to fix structurally: define an engineer role in your identity provider, attach every standard tool to it through group-based provisioning, and grant the whole set on day one rather than as a series of individual approvals. Anything that genuinely requires per-person approval should be a small list, and everything else should be automatic.

The sign that you have this problem is that new engineers ask in a team channel how to get access to something. Every one of those messages is a provisioning defect.

Needs first-hand data: For your next three hires, log every access request they need, with the timestamp raised and the timestamp granted. Total the waiting hours and compare it against the environment setup time everyone complains about. In most organisations the comparison is embarrassing, and it redirects the entire onboarding investment.

Devcontainers: a specification, not a product

A large share of the environment problem is now addressed by devcontainers, and it is worth being clear that this is an open specification rather than a product you buy. A JSON file in the repository describes a container image, the tools to install, the ports to forward, the editor extensions and the commands to run after creation. Multiple tools implement it, which is the point.

What it gives you

  • A single declarative definition of the development environment, stored in the repository, reviewed in pull requests and versioned with the code it builds.
  • Portability across implementations: the same definition is understood by cloud development environment products, by local editor integrations and by a command-line tool, so you are not tied to one vendor to open the project.
  • Elimination of the operating system split, because everyone develops inside the same Linux container regardless of what their laptop is running.
  • A lifecycle hook model that lets setup work, dependency installation, database migration, seed data, happen automatically on creation rather than being a list of instructions someone might skip.

What it does not do

  • It does not give you a fast environment by itself. A definition that installs dependencies on every create is slow every time; the speed comes from pre-built images and caching, which the specification allows but does not provide.
  • It does not solve state. Databases, message brokers and seed data still need a strategy, and a devcontainer that starts with an empty database leaves you exactly where you were.
  • It does not close the gap to production. The container you develop in is usually not the image you deploy, so drift between them is still possible and still your problem.
  • It does not handle credentials. Getting secrets into the environment safely is outside the specification, and every implementation solves it differently.

Adopting the specification is close to unambiguously correct for any team with more than a couple of engineers. Choosing which implementation runs it is the actual decision, and that is what the products below are about.

Gitpod

Gitpod homepage

Gitpod runs the development environment as an ephemeral cloud workspace created from the repository, with the environment definition living in the repository and prebuilds performing the expensive setup work in advance against the default branch. The prebuild mechanism is the important part for onboarding: the first workspace a new engineer opens has already had its dependencies installed and its build warmed, because that work happened before they arrived.

Pros

  • Prebuilds move dependency installation and initial build off the critical path, which is the single largest lever on setup time
  • Environment defined in the repository means it is reviewed, versioned and fixed once for everyone when it breaks
  • Ephemeral workspaces make it cheap to discard a broken environment, which removes a whole class of debugging nobody should be doing
  • Identical environment for every engineer regardless of operating system or machine specification

Cons

  • Cloud-hosted development means latency between keystroke and response, and engineers with strong opinions about their local setup resist it hard
  • Offline work is not possible, which is a genuine problem for commuting, travel and unreliable connections
  • Source code residing in a vendor environment is a security review conversation in regulated organisations
  • Prebuild configuration is its own maintenance burden, and a broken prebuild silently sends everyone back to slow cold starts

Best for: Teams who want a new engineer productive on day one without touching their laptop configuration, and who can accept working in a browser or a remote-attached editor.

Pricing: Free tier with limited monthly usage, then per-user subscription metered on workspace runtime, with self-hosted and dedicated options for organisations that need the environments inside their own boundary.

GitHub Codespaces

Codespaces is the same idea integrated directly into the code hosting platform, driven by the devcontainer specification and reachable from the repository page or from a local editor. Its advantage for onboarding is organisational rather than technical: access to a codespace follows repository access, so one fewer system needs provisioning and one fewer account needs creating.

Pros

  • Permissions and billing follow the existing platform relationship, so there is no separate access request in the onboarding queue
  • Standard devcontainer definitions, so the environment configuration is portable rather than vendor-specific
  • Prebuilt configurations remove installation time from first launch, and they rebuild automatically as the default branch moves
  • Connects from a local editor as well as the browser, which removes most of the objection from engineers who dislike browser editing

Cons

  • Only makes sense if your code is already on the platform, and a mixed hosting estate loses the main advantage
  • Usage-based billing on compute and storage means idle or forgotten codespaces cost money without anyone noticing
  • Machine sizes and configuration are bounded by what the platform offers, which is limiting for heavy builds
  • Offline work is not available, and connection quality directly determines whether the experience is pleasant or maddening

Best for: Teams whose repositories are already on GitHub and who want the environment to be one click from the code with no additional access to provision.

Pricing: Usage-metered on compute hours and storage with an included allowance on paid platform plans, so cost tracks how long environments are left running.

Coder

Coder homepage

Coder is the self-hosted approach: a control plane you run in your own infrastructure that provisions development workspaces as real infrastructure, defined with infrastructure-as-code templates, inside your own network. It exists because the hosted products cannot satisfy organisations whose source code and data are not allowed to leave their boundary, and because platform teams often want workspaces shaped like their production environment rather than like a vendor’s container.

Pros

  • Runs entirely in your own infrastructure, so source code, credentials and data never leave the boundary the security team defined
  • Workspaces are provisioned by infrastructure-as-code templates, so they can include whatever your production environment includes, including VPN-reachable internal services
  • Platform team controls machine shapes, images, network access and lifecycle policy centrally, which is the enforcement point that hosted products cannot offer
  • Works with local editors over a remote connection, so the developer experience does not have to be a browser

Cons

  • You are operating a platform, with all of the availability, upgrade and support burden that implies, and a broken control plane blocks everyone from working
  • Setup effort is substantially higher than a hosted product and requires a platform team that already knows your infrastructure well
  • Cost is your cloud bill plus the licence plus the engineers, which is frequently more than the hosted alternative once honestly totalled
  • The same offline and latency constraints as any remote environment still apply

Best for: Regulated or security-constrained organisations with a platform team, where code cannot sit in a vendor environment but standardised workspaces are still needed.

Pricing: Open source core with a commercial enterprise edition priced per user, plus all underlying infrastructure billed by your own cloud provider.

Nix

Nix takes a different approach entirely: instead of putting the environment in a container, it describes it as a set of precisely pinned package derivations, and reproduces exactly that set on any machine. A development shell defined in the repository gives every engineer bit-identical tool versions, on Linux and macOS, without a container runtime in the way. It is the strongest reproducibility guarantee available and also the steepest learning curve in this article.

Pros

  • Reproducibility is genuinely exact rather than approximately exact, so the entire category of “works on my machine” disappears
  • Runs natively on the host without container overhead, which keeps file system performance and tooling behaviour normal on macOS
  • One definition covers development shells, CI environments and in many cases production images, removing drift between them
  • No vendor, no service dependency and nothing that can be discontinued underneath you

Cons

  • The learning curve is severe, and in practice one or two people understand the configuration while everyone else is blocked when it breaks
  • Error messages are notoriously hard to interpret, which turns small problems into long ones for anyone not fluent
  • Packaging something not already in the ecosystem is real work, and a new engineer will hit that case eventually
  • Adoption is all-or-nothing in spirit: a half-adopted Nix setup gives you the complexity without the guarantee

Best for: Teams with at least one committed Nix advocate who need exact reproducibility across mixed Linux and macOS machines and will invest in learning it.

Pricing: No vendor and no bill. Open source package manager and ecosystem; the real cost is the engineering time to learn and maintain the configuration.

Docker Compose

Docker Compose describes a set of services, their images, their ports and their dependencies in one file, and starts them with a single command. For onboarding it solves the part that devcontainers alone do not: the database, the cache, the message broker and the other services the application needs in order to be usable rather than merely runnable.

Pros

  • Almost universally understood, so a new engineer probably already knows how to run it and a compose file needs no explanation
  • Handles the stateful dependencies that block a new engineer from actually using the application, which is where setup usually stalls
  • The same file is frequently reusable for integration testing and for ephemeral preview environments, so it earns its maintenance
  • Works locally with no service, no account and no network dependency beyond pulling images

Cons

  • Compose is not production configuration for most teams, so the local environment diverges from deployment in ways that hide bugs
  • Performance on macOS is noticeably worse than native execution, particularly for file-system-heavy workloads, and it is a daily irritation
  • Seed data is not addressed, so a new engineer gets a running stack with an empty database unless someone maintains a seed script
  • Compose files rot quietly, because the person who changes a service rarely runs the full local stack

Best for: Any team whose application needs a database and a couple of supporting services locally, as the baseline layer underneath whichever environment tool they choose.

Pricing: No separate charge for the tool itself; the container runtime it depends on has a free tier for personal and small-business use with paid subscriptions required for larger organisations.

Backstage

Backstage homepage

Backstage is a developer portal framework, and it appears here because onboarding pain is mostly orientation pain and a portal is the orientation tool. A catalogue that reliably answers who owns this service, where its dashboards are and where its runbook lives removes a large share of the questions a new engineer would otherwise ask a colleague. Its scaffolding templates also mean the first service they create starts correct.

Pros

  • An accurate service catalogue answers ownership and location questions immediately, which is the most repeated new-engineer question by a wide margin
  • Scaffolding templates mean a new engineer creating a service gets the organisation’s defaults without reading anything
  • Technical documentation rendered from the repositories keeps orientation material next to the code, which is the only place it stays current
  • Plugin ecosystem can pull dashboards, deployments and dependencies into one page per service, which shortens the mental model considerably

Cons

  • It is a framework you build and operate, so the cost is a permanent platform team rather than a licence
  • Its value depends entirely on catalogue accuracy, and a stale catalogue actively misleads new engineers, which is worse than no catalogue
  • Does nothing about environment setup or access provisioning, so it addresses one of the three categories only
  • Time from decision to something a new engineer benefits from is measured in quarters

Best for: Larger organisations where orientation across many services is the dominant onboarding cost and a platform team already exists.

Pricing: No vendor and no bill for the framework itself. Open source; the cost is the platform team required to build, host and maintain it, or a subscription if you choose a managed distribution instead.

How to choose

Measure before you buy. Reconstruct time to first merged pull request for your last few hires and find out which of the three categories dominates, because the right purchase is different for each and the intuition is usually wrong.

Access provisioning dominates. No tool on this list helps. Fix it in your identity provider: define an engineer role, attach every standard system to it through group-based provisioning, and reduce the set requiring individual approval to the genuinely sensitive ones. This is the highest-return onboarding work in most organisations and it is done by the identity team, not by engineering.

Environment setup dominates, and your team is on mixed operating systems. Adopt the devcontainer specification, run it locally first, and add Docker Compose underneath for the stateful dependencies. If setup remains slow after that, the bottleneck is dependency installation, and prebuilds in a cloud environment are what remove it: GitHub Codespaces if your code is on that platform, Gitpod otherwise, Coder if the code cannot leave your network.

Environment setup dominates and you need exactness rather than convenience. Nix, but only with a committed advocate who will own it. Without one it becomes a single point of failure wearing the costume of a reliability improvement.

Orientation dominates, across many services. Backstage or a hosted developer portal, and an owner for catalogue accuracy. The tooling is secondary to someone caring whether the data is true.

Then do the unglamorous thing, which outperforms every purchase above: make each new engineer fix the repository README as their first pull request, based on everything that was wrong when they followed it. It costs nothing, it is a real merged change on day one, and it repairs the document that every subsequent hire will read.

ToolCategory addressedRuns whereOfflinePicks itself when
Devcontainers (specification, not a product)Environment definitionAnywhere it is implementedLocally, yesYou want a portable environment definition
GitpodEnvironment setupVendor cloudNoPrebuilds must remove install time
GitHub CodespacesEnvironment setupVendor cloudNoCode is already on the platform
CoderEnvironment setupYour infrastructureNoCode cannot leave your network
NixEnvironment setupLocal machineYesExact reproducibility is worth the curve
Docker ComposeStateful dependenciesLocal machineYesThe app needs a database to be usable
BackstageOrientationYour infrastructureN/AMany services, ownership questions dominate

Frequently asked questions

What is a good time to first merged pull request?

There is no universal number, and any figure quoted without the context of codebase size, regulatory constraints and domain complexity is noise. The useful version of the question is comparative: measure your own, then measure it again after each change, and watch the direction. What is defensible to say is that the first merge should be possible on the first day for a trivial change, because everything preventing that is a mechanical obstacle rather than a knowledge gap. If the first day is not achievable, the reason is a defect list you can work through.

Should new engineers set up their environment locally or use a cloud environment?

Cloud environments remove the setup problem completely on day one, which is exactly when it is most expensive, and that is a strong argument. They also introduce latency, cost per hour and an offline gap that becomes a daily irritation for people who commute or travel. A reasonable compromise that many teams land on is a repository-defined environment that runs either way, which is what the devcontainer specification allows: cloud for the first week, local afterwards for anyone who prefers it. The full comparison is in cloud development environments and local development environment tools.

Why is access provisioning so often the bottleneck?

Because the delay lives in another team’s queue and therefore never appears in an engineering retrospective. Engineering sees an engineer who is not shipping and concludes onboarding is hard; nobody logs that a stack of separate approvals was still outstanding. The fix is structural rather than technical: group-based provisioning driven by role, granted on the first day, with individual approval reserved for genuinely sensitive access. Automated deprovisioning matters just as much, and both are covered in SCIM provisioning tools.

Does an internal developer platform speed up onboarding?

It addresses orientation, which is one of the three costs, and only if the catalogue is accurate. An out-of-date catalogue sends a new engineer to the wrong owner and the wrong runbook, which is worse than having no portal because it consumes their trust as well as their time. The adoption problem behind that is covered in internal developer platforms.

What is the single highest-return onboarding improvement?

Fix the repository README and keep it fixed, by making its correction the first task of every new engineer. Every other item on this list is infrastructure that needs maintaining; this one costs nothing, produces a real merged pull request on day one, and repairs itself on every hire. Teams skip it because it is unglamorous and because nobody owns it, which is precisely why it stays broken.