Local development setups are losing ground fast. A growing share of engineering teams now spin up a full workspace in a browser tab instead of installing a toolchain on a laptop, and three platforms are absorbing most of that shift: GitHub Codespaces, Gitpod (now rebranded as Ona), and Google Cloud Workstations. Each promises the same basic pitch, a ready-to-code environment provisioned on someone else’s servers, but the pricing models, hardware ceilings, and enterprise controls behind that pitch differ enough to change which one actually makes sense for a given team. This comparison breaks down real 2026 pricing, machine specs, and trade-offs across all three, using a concrete 8-vCPU workload to show exactly where the cost gaps show up.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Is a Cloud Development Environment, and Why Teams Are Switching
A cloud development environment (CDE) moves the compute, storage, and runtime a developer needs off a personal machine and onto a remote server, accessed through a browser or a thin local client. Instead of cloning a repository, installing dependencies, and configuring a local toolchain, a developer opens a link and gets a running container or virtual machine that already has the code, the dependencies, and the editor wired up. The pitch is consistency: every teammate gets an identical environment, onboarding drops from days to minutes, and a stolen or wiped laptop no longer means lost work.
The three platforms compared here approach that problem from different angles. GitHub Codespaces builds cloud development environments directly into the GitHub workflow, tying billing and machine configuration to a devcontainer file in the repository. Gitpod pioneered the ephemeral, prebuilt workspace model years before Codespaces existed, and in 2025 it restructured its business around a new brand, Ona, and a credit-based pricing system. Google Cloud Workstations takes a heavier, more infrastructure-native approach, exposing full Compute Engine virtual machines behind a managed control plane built for regulated enterprises that need VPC isolation and IAM-level control over every workspace.
One quiet trend underpins all three: the devcontainer.json format, originally popularized by Microsoft’s VS Code Remote Containers extension, has become the closest thing this space has to a shared standard. Both GitHub Codespaces and Ona read the same devcontainer schema, which means a repository configured for one can usually open in the other with little to no editing. Google Cloud Workstations sits outside that standard, relying instead on container images and Compute Engine machine definitions, a distinction that matters more than it looks once a team starts thinking about switching costs down the line.
GitHub Codespaces: Pricing, Machine Types, and How Billing Works
GitHub Codespaces bills on two dimensions: compute, measured in core-hours, and storage, measured in GB-months. According to GitHub’s own billing documentation, compute costs scale linearly with the number of virtual cores in the selected machine type. A 2-core machine costs $0.18 per hour, a 4-core machine costs $0.36 per hour, an 8-core machine costs $0.72 per hour, a 16-core machine costs $1.44 per hour, and the largest available option, a 32-core machine, costs $2.88 per hour. Storage is billed separately at $0.07 per GB-month, and that charge keeps accruing even after a codespace is stopped, since the disk image itself still occupies space.
Personal accounts get a monthly allowance before any charges apply. GitHub Free includes 120 core-hours and 15 GB-month of storage per month, while GitHub Pro raises that to 180 core-hours and 20 GB-month, per GitHub’s Enterprise Cloud billing docs. Organization and enterprise accounts do not inherit any free quota. Every core-hour an organization’s members consume is billed pay-as-you-go against the org’s configured payment method, with administrators able to cap spending through org-level policies.
Machine types pair core counts with fixed memory ratios: a 2-core codespace ships with 8 GB of RAM, a 4-core with 16 GB, an 8-core with 32 GB, a 16-core with 64 GB, and the 32-core ceiling comes with 128 GB of RAM. That 1:4 core-to-RAM ratio stays constant across every tier, which keeps the pricing table simple but means teams that need RAM-heavy configurations without matching CPU counts have to overpay for cores they don’t need.
Gitpod’s Sunset and the Move to Ona: What Changed
Anyone researching Gitpod in September 2026 runs into a naming problem immediately. Gitpod Classic, the pay-as-you-go browser workspace product that most tutorials, READMEs, and “Open in Gitpod” badges still reference, was sunset on October 15, 2025. The company rebranded its current product as Ona, and pricing moved from a simple hours-based model to a credit system built around what Ona calls Compute Units, or OCUs.
Under the current structure, Ona’s Core plan starts at $20 per month and includes between 80 and 2,200 OCUs depending on the specific tier, support for up to 100 team members, and environments that can scale as large as 32 vCPUs, 128 GB of RAM, and 200 GB of disk, all running on Ona-managed AWS infrastructure. Teams that burn through their included OCUs can buy more at $10 per 40 additional units. Enterprise pricing is not published. That tier adds AWS and GCP runners inside the customer’s own VPC, single sign-on, and audit trails, but the customer also pays their own separate cloud infrastructure bill on top of whatever Ona charges for the platform layer.
The credit-based model creates a real problem for cost comparison. Because OCUs don’t map to a published dollar-per-vCPU-hour rate, a team can’t calculate an exact monthly bill the way they can with Codespaces’ per-core pricing or Cloud Workstations’ per-component pricing. Multiple 2026 review aggregators, including AISO Tools and CompareTiers, list slightly different numbers for legacy Gitpod tiers still shown on some pricing pages, ranging from $9 to $25 per user per month, which reflects the messy overlap between the old Gitpod SaaS product and the new Ona Core structure rather than an actual price change.
Google Cloud Workstations: Enterprise Cloud Desktops Explained
Google Cloud Workstations takes a fundamentally different architectural approach than the other two. Instead of packaging a container as a lightweight workspace, it provisions a full Compute Engine virtual machine behind a managed control plane, which means it inherits the entire Compute Engine machine-type catalog, including high-memory and GPU-backed configurations that neither Codespaces nor Ona currently offers at a comparable price point.
That flexibility comes with a pricing structure built from several separate components, all documented on Google’s official Cloud Workstations pricing page. A control plane fee of $0.20 per cluster, per hour, accrues continuously regardless of whether any workstation inside that cluster is actually running. A workstation management fee of $0.05 per vCPU, per hour, applies only while a specific workstation is active. On top of those two fees sits standard Compute Engine VM pricing for whichever machine type is selected, plus persistent disk and network charges billed the same way they would be for any other GCP compute resource.
For a standard e2-standard-2 machine (2 vCPU, 8 GiB RAM), the VM itself costs $0.0670 per hour. An e2-standard-4 (4 vCPU, 16 GiB) runs $0.1340 per hour, an e2-standard-8 (8 vCPU, 32 GiB) runs $0.2680 per hour, an e2-standard-16 (16 vCPU, 64 GiB) runs $0.5361 per hour, and an e2-standard-32 (32 vCPU, 128 GiB) runs $1.0722 per hour. Available machine types extend well past that range: Google’s available machine types documentation lists configurations scaling up to 96 vCPUs and 768 GB of RAM on high-memory series, plus dedicated GPU workstation types built around A100 40GB accelerators for teams running ML workloads directly in their dev environment. There is no free tier for Cloud Workstations at any usage level.
Google shipped a notable update to the service in late August 2026, adding support for Hyperdisk Balanced High Availability on persistent directories, according to the Cloud Workstations release notes. The feature currently applies to workstations running on A3, C3, C4, G4, M3, N4, N4D, and Z3 machine series, and it targets teams that need their development disks to survive zonal failures without manual snapshot management.
Full Specs Comparison: Codespaces vs Gitpod/Ona vs Cloud Workstations
The table below lines up the three platforms across the specifications that matter most when picking a cloud development environment: pricing model, free tier, hardware ceiling, IDE support, and compliance posture.
| Category | GitHub Codespaces | Gitpod (Ona) | Google Cloud Workstations |
|---|---|---|---|
| Pricing model | Per core-hour + per GB-month storage | Credit-based (OCUs) flat monthly plan | Control plane + per-vCPU + VM + disk, all separate |
| Entry price | $0.18/hour (2-core) | $20/month (Core plan) | No flat entry, usage-based only |
| Free tier | 120 core-hours/mo (Free), 180 (Pro) | Limited free OCU allotment | None |
| Storage cost | $0.07/GB-month, billed even when stopped | Included up to plan disk limit (200 GB on Core) | Standard persistent disk rates, billed separately |
| Max machine size | 32 vCPU / 128 GB RAM | 32 vCPU / 128 GB RAM (Core plan cap) | Up to 96 vCPU / 768 GB RAM (machine-type dependent) |
| GPU support | Not offered | Not published for Core plan | Yes, including A100 40GB configurations |
| Primary IDE | VS Code (web + desktop) | Browser-based VS Code | Self-installed, any Linux-compatible IDE |
| JetBrains support | Via JetBrains Gateway | Via desktop + remote gateway | Via JetBrains Client on the VM |
| Enterprise VPC isolation | Inherited from GitHub Enterprise Cloud | Enterprise tier only, customer-owned AWS/GCP VPC | Native, since it runs inside the customer’s own GCP project |
| SOC 2 Type II | Covered via GitHub Enterprise Cloud | Not explicitly published | Explicitly listed on Google Cloud’s SOC 2 compliance page |
| Team member cap (entry plan) | No cap, org-managed billing | Up to 100 members on Core | No cap, IAM-managed |
| Recent major update | Stable core-hour pricing through Aug 2026 | Full Gitpod-to-Ona brand and pricing transition | Hyperdisk Balanced HA support (Aug 2026) |
Monthly Pricing Compared: What an 8-vCPU Workspace Really Costs
Published rate cards only tell part of the story. To see where the actual cost gap shows up, it helps to price out a single realistic workload: an 8-vCPU workspace used 160 hours in a month, roughly 8 hours a day across 20 working days, with a 32 GB disk attached.
On GitHub Codespaces, that workload runs on an 8-core machine at $0.72 per hour. Compute for 160 hours costs $115.20, and storage for a 32 GB disk at $0.07 per GB-month adds $2.24, for a total of roughly $117.44 per month.
On Google Cloud Workstations, the same 8-vCPU configuration maps to an e2-standard-8 machine. The VM itself costs $0.2680 per hour, so 160 hours of active use costs $42.88. The workstation management fee adds $0.05 per vCPU per hour, which for an 8-vCPU machine running 160 hours works out to $64.00. The control plane fee is where the model diverges from the other two platforms: it bills $0.20 per cluster, per hour, continuously, whether or not anyone is actively using a workstation in that cluster. Over a full 730-hour month, that fee alone totals $146.00. Add the three components together and a single 8-vCPU Cloud Workstations setup costs approximately $252.88 per month before disk and network charges, a gap of roughly $135 above the equivalent Codespaces configuration.
That control plane fee amortizes better at scale. A team running ten workstations off the same cluster pays the $146 control plane charge once, not ten times, which brings the effective per-workstation overhead down sharply as headcount grows. For a single developer or a small team with only one or two active workstations, though, Cloud Workstations carries a real cost penalty compared to Codespaces.
Ona’s Core plan doesn’t translate cleanly into this comparison because it bills in OCUs rather than dollars per vCPU-hour. A team pays a flat $20 per month for the Core plan, which covers up to 100 members and includes between 80 and 2,200 OCUs depending on tier, and buys additional capacity at $10 per 40 OCUs when it runs out. For teams that stay within the included allotment, $20 per month undercuts both competitors by a wide margin. For teams that consume enough compute to need frequent OCU top-ups, the real monthly cost becomes difficult to predict in advance, which several 2026 reviews flag as the platform’s core pricing weakness.
| Scenario | GitHub Codespaces | Gitpod (Ona) | Google Cloud Workstations |
|---|---|---|---|
| Solo developer, light use (~40 hrs/mo, 4-core) | ~$14.40 compute + storage | Free tier likely sufficient | No free tier; ~$40-60 estimated |
| Solo developer, heavy use (160 hrs/mo, 8-core) | ~$117.44/mo | $20/mo Core plan (if within OCU limit) | ~$252.88/mo (single-cluster estimate) |
| 5-person team, moderate use | Pay-as-you-go, no free org quota | $20/mo covers up to 100 members | Control plane fee shared across cluster |
| Enterprise, 50+ developers | Custom spending limits, org policies | Custom Enterprise pricing, not published | Usage-based under GCP contract, CUDs available |
Machine Sizes and Hardware Ceilings Compared
For most day-to-day development work, all three platforms offer more than enough headroom. The gap opens up at the extremes. GitHub Codespaces and Ona’s Core plan both cap out at the same ceiling, 32 vCPUs and 128 GB of RAM, which suggests both vendors are targeting the same class of workload: standard web, backend, and mobile development, plus moderately sized monorepo builds.
Google Cloud Workstations breaks past that ceiling by a wide margin because it inherits the full Compute Engine machine catalog rather than a curated subset. High-memory series scale up to 96 vCPUs and 768 GB of RAM, and dedicated GPU workstation types support A100 40GB accelerators, according to Google’s available machine types documentation. That range matters for teams doing large-scale data processing, ML model development, or any workload that needs to run directly inside the development environment rather than being offloaded to a separate training cluster.
IDE and Editor Support Across All Three Platforms
GitHub Codespaces centers on VS Code, both the browser-based version and the desktop app connecting over a remote tunnel, with full devcontainer.json support for customizing the environment. JetBrains IDEs connect through GitHub’s JetBrains Gateway integration, letting developers keep their preferred IntelliJ-based workflow while the actual compute runs remotely.
Gitpod built its reputation on a browser-based VS Code experience with strong prebuild support, and that heritage carries into the Ona rebrand. JetBrains IDEs connect through a desktop client paired with a remote gateway, mirroring the Codespaces approach. Google Cloud Workstations takes the most open-ended approach of the three: because each workstation is a full VM, developers can install VS Code, any JetBrains product, or any Linux-native editor they prefer, accessed either through a browser-based code-server setup or a JetBrains Client connection to the underlying machine.
Collaboration Features: Prebuilds, Shared Workspaces, and Port Forwarding
Beyond raw compute, the day-to-day feel of a cloud development environment comes down to how well it supports a team working together rather than a single developer working alone. GitHub Codespaces supports prebuilds, which pre-install dependencies and cache the container image ahead of time so a new codespace doesn’t have to run a full setup script from scratch every time someone opens a branch. It also automatically forwards ports for local servers, making it straightforward to preview a running web app directly inside the browser tab hosting the editor.
Ona inherits Gitpod’s original prebuild system, which was arguably the feature that put ephemeral cloud workspaces on the map before Codespaces existed. Prebuilds trigger automatically on new commits to a configured branch, so a teammate opening a fresh environment for code review gets a workspace that’s already built and ready rather than one still installing packages. Google Cloud Workstations doesn’t offer an equivalent prebuild concept in the same sense, since each workstation is a persistent VM rather than an ephemeral container spun up fresh per session; instead, teams typically bake dependencies into a custom container image ahead of time and rely on the workstation staying provisioned between sessions.
Vendor Lock-In and Environment Portability
Switching costs deserve more attention than most teams give them before signing up. Because Codespaces and Ona both read the devcontainer.json standard, a team that starts on one and later wants to move to the other can usually bring its environment definition along mostly intact, adjusting only platform-specific extensions or secrets handling. That portability doesn’t extend to the underlying compute, though: Codespaces environments run on GitHub-managed infrastructure, while Ona’s Core plan runs on Ona-managed AWS, and Enterprise customers run their own AWS or GCP infrastructure behind Ona’s control plane.
Google Cloud Workstations locks a team into the GCP ecosystem more tightly than the other two, both by design and by necessity. Its pricing, IAM integration, and machine catalog are all native GCP concepts, and moving off the platform means rebuilding the environment definition as a container image rather than porting a devcontainer.json file. For a team already committed to Google Cloud for its production infrastructure, that tight coupling is a feature rather than a bug, since it means one identity system and one set of network policies govern both production workloads and developer environments. For a team that might want to move clouds later, it’s worth weighing as a real switching cost rather than an afterthought.
Enterprise Controls: SSO, Audit Logs, and VPC Isolation
Enterprise buyers care less about per-hour pricing and more about whether a platform fits inside an existing security perimeter. GitHub Codespaces inherits single sign-on, audit logging, and org-level policy enforcement from GitHub Enterprise Cloud, since Codespaces itself is a feature layered on top of that platform rather than a standalone product with its own identity system.
Ona’s Enterprise tier adds AWS and GCP runners that execute inside the customer’s own VPC, along with SSO and audit trails, according to Ona’s published plan comparison. That structure means the customer manages two separate bills, one to Ona for the platform layer and one to AWS or GCP for the underlying compute, which adds operational overhead compared to a single consolidated invoice.
Google Cloud Workstations has the most natural fit for VPC isolation of the three, simply because every workstation already runs inside the customer’s own Google Cloud project. Enterprise controls like IAM roles, VPC Service Controls, and Security Command Center integration come from the surrounding GCP environment rather than a separate Workstations-specific subscription tier, which means enterprises already standardized on GCP get enterprise-grade isolation without negotiating a separate enterprise contract for the CDE layer itself.
Security and Compliance Certifications
Google Cloud Workstations has the clearest documented compliance position of the three. Google Cloud’s SOC 2 compliance page explicitly names Cloud Workstations among the services covered by its quarterly SOC 2 Type II reports, which enterprises can download directly through Google’s Compliance Reports Manager.
GitHub Codespaces sits under GitHub Enterprise Cloud’s broader compliance posture, which includes SOC 2 Type II coverage at the platform level. GitHub doesn’t publish a Codespaces-specific compliance statement separate from that platform-wide certification, so organizations evaluating Codespaces for regulated workloads generally rely on GitHub Enterprise Cloud’s existing compliance documentation. Ona’s public pricing and product pages emphasize SSO and audit trails at the Enterprise tier but don’t publish a specific SOC 2 or ISO certification reference, which means teams with strict compliance requirements should request that documentation directly during a sales conversation rather than assuming coverage.
Benchmarking the Three Platforms: What the Data Actually Shows
Startup latency is the benchmark developers ask about most, and it’s also the one none of the three vendors publish an official number for. GitHub’s Codespaces documentation and feature pages describe prebuilds as a way to speed up environment creation but stop short of a measured time-to-ready figure. Ona’s pricing and product pages make similar qualitative claims about fast browser-based workspaces without a published benchmark. Google’s Cloud Workstations documentation focuses entirely on configuration options and release notes rather than boot-time measurements. That absence is itself a useful data point: any startup-time claim circulating for these platforms is a third-party estimate from an individual test run, not a vendor-verified benchmark, and should be treated with the same skepticism you’d apply to any single, unrepeatable measurement.
What is independently verifiable, across GitHub’s own billing documentation, Google Cloud’s official pricing page, and Ona’s published plan comparison, is the cost and capability data already broken down above. That’s the benchmark that actually holds up to scrutiny for a September 2026 buying decision: dollar-for-dollar compute cost at a fixed machine size, maximum hardware ceiling, and what’s included in the base plan before overage charges kick in.
Real-World Use Cases: Who Should Use Which Platform
The right platform depends heavily on where a team’s code already lives and what kind of workload it runs day to day. Five scenarios come up often enough to be worth calling out directly, each pointing toward a different one of the three platforms based on real constraints rather than brand preference.
- Open-source maintainers reviewing pull requests: GitHub Codespaces integrates directly into the PR review flow, letting a maintainer spin up the exact branch a contributor submitted with one click, inside the same GitHub interface they already use for review comments.
- Small startups standardizing onboarding: A five-person team on Ona’s Core plan gets up to 100 member slots and a flat $20 monthly starting price, which keeps early-stage costs predictable while still giving every new hire an identical environment on day one.
- Regulated enterprises with strict VPC requirements: Financial services and healthcare teams already standardized on Google Cloud benefit from Cloud Workstations running natively inside their existing GCP project, inheriting IAM policies and VPC Service Controls without a separate compliance review for the dev environment layer.
- ML engineers who need GPU access inside their dev loop: Cloud Workstations is the only one of the three offering GPU-backed machine types, including A100 40GB configurations, which matters for teams iterating on model code without shipping every test run to a separate training cluster.
- Contract and agency developers juggling multiple client codebases: The ability to spin up and tear down isolated, disposable environments per client repository, without leaving dependencies installed on a personal laptop, fits Codespaces’ and Ona’s ephemeral workspace model better than a persistent Cloud Workstations VM.
A sixth scenario worth naming separately: bootcamp instructors and technical trainers running workshops for large cohorts of students who don’t have a consistent local setup. Handing every student a link to a pre-configured Codespace or Ona workspace removes an entire category of “it works on my machine” support requests during a live session, and the ephemeral nature of both platforms means nobody has to worry about cleaning up a shared training repository afterward. Cloud Workstations is a weaker fit here specifically because of the always-on control plane fee, which keeps billing for the full duration a training cluster exists rather than scaling cleanly with a short workshop window.
| Team profile | Best-fit platform | Why |
|---|---|---|
| Open-source project on GitHub | GitHub Codespaces | Native PR integration, generous personal free tier |
| Early-stage startup, under 10 devs | Gitpod (Ona) | Flat $20/mo covers up to 100 members |
| Regulated enterprise on GCP | Google Cloud Workstations | Native VPC isolation, SOC 2 Type II coverage |
| ML/data science team | Google Cloud Workstations | Only platform with GPU-backed machine types |
| Coding bootcamp or workshop host | GitHub Codespaces or Ona | Ephemeral, no cleanup, no always-on fee |
| Agency with multiple client repos | GitHub Codespaces or Ona | Disposable, isolated environments per client |
Pros and Cons of Each Platform
GitHub Codespaces
Codespaces wins on simplicity. One pricing dimension for compute, one for storage, and a generous personal free tier make it easy to reason about cost for individual developers and small teams already living inside GitHub. The tradeoff is that storage keeps billing even after a codespace stops, which reviewers repeatedly flag as a hidden cost for teams that spin up many environments and forget to delete them, and the platform only makes sense for teams whose code already lives on GitHub.
Gitpod (Ona)
Ona’s flat $20 monthly Core plan is the cheapest entry point of the three for a small team, and its 100-member cap on that single plan is generous compared to per-seat pricing elsewhere. The downside is the OCU credit system itself: because compute doesn’t map to a published per-hour rate, budgeting for a growing team gets harder over time, and the 2025 Gitpod-to-Ona transition has left enough stale documentation and pricing pages online that new evaluators can end up comparing the wrong numbers.
Google Cloud Workstations
Cloud Workstations offers the widest hardware range, the cleanest native VPC isolation, and explicit SOC 2 Type II coverage, which makes it the strongest fit for regulated enterprises already on GCP. The cost is real complexity: three separate fee components, a control plane charge that bills continuously regardless of usage, and no free tier at any level, which together make it the most expensive option for small teams or solo developers running only one or two workspaces at a time.
Migration Guide: Moving From Local Development to the Cloud
Switching a team from local development to a cloud development environment works best as a staged rollout rather than a single cutover. The following sequence applies whether the destination is Codespaces, Ona, or Cloud Workstations, with platform-specific notes where the steps diverge.
- Pick a pilot repository with a well-understood build process, not the team’s most complex monorepo, to surface configuration issues early without blocking critical work.
- Define the environment as code. For Codespaces and Ona, this means writing a devcontainer.json that pins the base image, installs dependencies, and forwards the ports the app needs. For Cloud Workstations, this means building or selecting a container image for the workstation configuration and defining the Compute Engine machine type in the workstation config.
- Test the environment startup end-to-end, including any database seeding or environment variable injection the app needs before a developer can start coding immediately after the workspace loads.
- Set spending guardrails before rolling out to the full team. On Codespaces, configure org-level spending limits and machine-type restrictions. On Ona, monitor OCU consumption against the plan’s included allotment. On Cloud Workstations, set budget alerts through Google Cloud’s billing console, since the continuous control plane fee accrues even during idle periods.
- Migrate secrets and credentials out of local .env files and into the platform’s native secrets handling, GitHub Codespaces secrets for repos on GitHub, or GCP Secret Manager for Cloud Workstations deployments.
- Run the pilot team for two to four weeks before expanding, tracking both developer feedback and actual monthly spend against the estimates calculated during planning.
- Expand in waves by team rather than all at once, giving each new group a short onboarding session on stopping unused environments and understanding the platform’s specific billing quirks.
A minimal devcontainer.json for a Node.js project, compatible with both GitHub Codespaces and Ona, looks like this:
{
"name": "node-dev-environment",
"image": "mcr.microsoft.com/devcontainers/javascript-node:20",
"forwardPorts": [3000],
"postCreateCommand": "npm install",
"customizations": {
"vscode": {
"extensions": ["dbaeumer.vscode-eslint", "esbenp.prettier-vscode"]
}
}
}Common Migration Pitfalls and Cost Traps to Avoid
The most common mistake teams make after adopting a cloud development environment is leaving workspaces running, or worse, stopped but not deleted. On Codespaces, a stopped codespace still bills storage at $0.07 per GB-month indefinitely until someone explicitly deletes it, which adds up quickly across a team that creates a new codespace for every branch. On Cloud Workstations, the continuous control plane fee means an idle cluster with zero active workstations still costs $0.20 per hour, so teams that provision a cluster for a short-term project and forget to tear it down end up paying for infrastructure nobody is using.
A second common trap is under-provisioning the pilot environment’s machine size to save money, then discovering mid-rollout that the default configuration can’t handle the team’s actual build times. It’s worth benchmarking a real build or test suite run on the target machine size before committing to a team-wide rollout, since resizing after the fact means re-onboarding everyone who already adapted their workflow to the smaller configuration.
A third trap shows up specifically on Ona’s Core plan: teams that size their OCU allotment based on a light pilot period, then get surprised when full-team usage burns through the monthly credit pool days before the billing cycle resets. Since OCUs don’t map to a transparent per-hour rate, the fix isn’t a simple calculation, it’s tracking actual consumption during the pilot and building in headroom, or budgeting for the $10-per-40-OCU top-up rate as a recurring line item rather than an occasional overage. Teams evaluating Cloud Workstations should also account for network egress charges separately, since a developer pulling large datasets or container images from outside the workstation’s region can add a cost that doesn’t show up in the headline control-plane-plus-VM math.
Cost Optimization Tips for Cloud Development Environments
A handful of practical habits keep cloud development environment spend under control regardless of which platform a team picks. Setting an automatic idle-timeout so environments suspend after a period of inactivity prevents the most common source of runaway compute charges. Deleting codespaces and workstations after a pull request merges, rather than letting them accumulate, avoids the storage charges that keep billing on stopped environments. For Cloud Workstations specifically, consolidating multiple developers onto shared clusters spreads the fixed control plane fee across more active workstations, which is the single biggest lever for bringing its effective per-developer cost down toward Codespaces’ pricing. Reviewing machine-type assignments quarterly, rather than defaulting every new hire to the largest available configuration, also keeps compute costs proportional to actual workload rather than habit.
The Verdict: Which Cloud Development Environment Should You Pick
There isn’t a single winner here, because the three platforms are optimized for different starting points. For a team already living on GitHub that wants the simplest possible pricing model and the tightest PR-review integration, GitHub Codespaces is the safer default, with its $0.18-per-core-hour baseline and generous personal free tier making costs easy to predict. For a small team or startup that wants the lowest fixed monthly cost and doesn’t need enterprise-grade VPC isolation on day one, Ona’s $20 flat Core plan undercuts both competitors, as long as the team stays realistic about OCU consumption and monitors it before it becomes a surprise bill. For a regulated enterprise already standardized on Google Cloud, or any team that needs GPU-backed compute directly inside its development loop, Cloud Workstations justifies its roughly $199-per-month premium over an equivalent Codespaces setup with native VPC isolation, explicit SOC 2 Type II coverage, and a hardware ceiling that goes far beyond what the other two platforms offer.
The practical starting point for most teams evaluating this decision in September 2026: default to Codespaces if the codebase is already on GitHub and the team is under 20 developers, evaluate Ona if flat monthly pricing matters more than granular cost tracking, and reach for Cloud Workstations only once compliance requirements or GPU workloads make the added cost and complexity worth it.
Frequently Asked Questions
Is GitHub Codespaces free?
Personal GitHub accounts get a monthly allowance before charges apply: GitHub Free includes 120 core-hours and 15 GB-month of storage, while GitHub Pro includes 180 core-hours and 20 GB-month. Usage beyond that allowance bills at $0.18 per core-hour and $0.07 per GB-month. Organization and enterprise accounts do not receive a free quota and are billed pay-as-you-go from the first hour of usage.
What happened to Gitpod, and is it still available?
Gitpod Classic, the original pay-as-you-go browser workspace product, was sunset on October 15, 2025. The company now operates under the Ona brand, with a Core plan starting at $20 per month that includes a credit allotment measured in Ona Compute Units rather than a simple hourly rate. Existing “Open in Gitpod” badges and legacy documentation may still reference the old product, so teams evaluating it in 2026 should confirm they’re looking at current Ona pricing rather than archived Gitpod Classic pages.
Does Google Cloud Workstations have a free tier?
No. Google’s official pricing documentation confirms Cloud Workstations offers no free usage tier at any level. Every workstation incurs a control plane fee, a per-vCPU management fee, and standard Compute Engine VM pricing from the moment a cluster is created, which makes it the most expensive of the three platforms to evaluate for hobbyist or personal use.
Which platform supports GPU workloads?
Google Cloud Workstations is currently the only one of the three offering GPU-backed machine configurations, including workstation types built around A100 40GB accelerators. Neither GitHub Codespaces nor Ona’s Core plan publishes GPU-enabled machine options as of September 2026.
Can I use JetBrains IDEs with all three platforms?
Yes, though the connection method differs. GitHub Codespaces and Ona both support JetBrains IDEs through a desktop client paired with a remote gateway connection. Google Cloud Workstations, since it exposes a full virtual machine, supports JetBrains Client connecting directly to the VM, alongside any other Linux-compatible IDE a developer wants to install.
Why does my Cloud Workstations bill keep growing even when I’m not coding?
The most likely cause is the control plane fee, which bills $0.20 per cluster, per hour, continuously, regardless of whether any workstation inside that cluster is actively in use. Unlike the per-vCPU management fee, which only accrues while a workstation is running, the control plane charge keeps accumulating for as long as the cluster itself exists. Deleting unused clusters, rather than just stopping individual workstations, is the fix.
Is it worth switching from a local setup to a cloud development environment?
It depends on team size and onboarding frequency. Teams that hire often, work across many repositories, or need to standardize environments for compliance reasons tend to see the clearest return, since onboarding time drops and environment drift between developers disappears. Solo developers or very small teams with a stable, simple toolchain may find the monthly cost harder to justify against a laptop they already own outright.
Can I migrate between these three platforms later if I change my mind?
Migrating between Codespaces and Ona is relatively straightforward since both use the same devcontainer.json standard for environment configuration, so a working config largely transfers with minor adjustments. Moving to or from Google Cloud Workstations requires more rework, since it relies on container images and Compute Engine machine configurations rather than the devcontainer specification, which means the environment definition itself typically needs to be rebuilt rather than ported directly.
Related Coverage
- AWS Fargate vs Cloud Run vs Container Apps: $29.55 Gap [2026]
- SNS vs SQS vs EventBridge: 4x Message Size Gap [2026]
- Confluent vs MSK vs Redpanda: 46x Kafka Price Gap [2026]
- LaunchDarkly vs Unleash vs GrowthBook: $2,800 Gap [2026]
- DigitalOcean vs Vultr vs Lightsail: 2.2x IOPS Gap [2026]
