New The Cloud-Native Foundations 2026 Trend Report, in partnership with DZone. Get the report.

Preview Environments: The Complete Guide

What a preview environment is, how it relates to staging and ephemeral environments, the four ways to build one, how the platforms compare, and what coding agents change about them.

Author
Arjun Iyer
Published
July 31, 2025
Updated
October 11, 2026
Reading time
29 min

A preview environment is a temporary, isolated environment created for a change, most often automatically for each pull request, where a person or a coding agent can try the change through the application’s web or mobile front end before it merges. For a pull request, it is created when the pull request opens, gets its own URL or routing key, and is deleted when the pull request closes. Developers and coding agents also create one earlier, during local development, to preview a change before any pull request exists. Teams also call it a PR environment or a pull request environment.

Frontend platforms made the idea ordinary. Netlify and Vercel build every branch and post a link on the pull request, and reviewers got used to clicking through a change instead of reading it. For a frontend that is nearly free, because each build is a self-contained bundle. For a backend made of dozens of services, databases and message queues, the preview has to lead somewhere the whole system exists, and that is where the approaches split.

The hard question is not whether to have preview environments but what each one copies. Copying the whole stack per pull request gives every reviewer a faithful system and a bill that grows with every service and every open pull request. Coding agents make that bill the constraint, because every pull request an agent opens wants its own preview. When a full copy takes 15 minutes or more to deploy, 1,000 pull requests a day turn previews into a queue, and the CircleCI 2026 report found that the teams pulling ahead are the ones whose environments absorb a tenfold surge in pull requests. What scales is selective isolation: each preview copies only what its pull request needs, usually just the changed services, and uses the real services, data and queues around them.

This guide covers what a preview environment is and is not, how it differs from staging and from ephemeral environments, how one gets from pull request to URL, the four ways to build them, the platforms compared in one table, CI/CD workflows, monorepos, databases and message queues, what coding agents change, cost, and a checklist. A preview is one use of an ephemeral environment, the broader idea covered in the complete guide to ephemeral environments: the environment that serves a preview also runs automated frontend, backend, functional, security and performance tests.

What is a preview environment?

A preview environment is one change’s own running version of the application, usually a pull request’s, reached through its web or mobile front end by a URL or a routing key, and deleted when the change is done. It exists so a change can be tried, not only read.

Previewing is manual testing, and manual does not mean human. A product manager clicking through a checkout flow and a coding agent driving the same flow in a browser or a mobile emulator, ad hoc, to see whether the change behaves are both previewing.

What are preview environments for? Four jobs:

  • Reviewing behavior, not code. QA, product and design click through the change before it merges, which preview environments for QA and stakeholder review covers in depth.
  • Letting a coding agent explore its change through the web or mobile app the way a tester would, before a person looks.
  • Trying a frontend change against the real backend behind it, or a backend change through the screens that use it.
  • Showing a change to a customer or an executive from a link.

What a preview is not:

  • Automated testing. Functional, security and performance suites run in the same ephemeral environment with nobody looking at it, which is testing, not previewing.
  • A way to test changes to the cluster itself, such as a new operator or CRD, unless each preview is its own virtual cluster.
  • The final release check. Every change that merged still meets the others after merge, in staging or in a canary.

The same idea goes by several names. PR environment and pull request environment name the trigger. GitLab calls its version review apps, Netlify calls them Deploy Previews, and Vercel calls them Preview Deployments. Branch environment and per-PR environment are common in platform teams. Whatever the name, the meaning is one environment per pull request, deleted with it.

Preview environments vs ephemeral environments

Every preview environment is an ephemeral environment, but an ephemeral environment does much more than previews. Ephemeral describes the lifecycle: created for one change and deleted after it. Preview describes one use of it: trying the change through the web or mobile front end, manually, whether a person clicks through or a coding agent explores ad hoc. The same ephemeral environment also runs automated tests of every kind, frontend and backend, functional, security and performance, from CI or from an agent’s loop, with nobody looking.

The distinction matters when you pick tools. Preview tooling optimizes for a shareable URL and a comment on the pull request. Ephemeral environment tooling serves both uses: a URL that people and agents explore, and an API that test suites call. Signadot provides ephemeral environments, so the preview and the automated tests run against the same change in the same place.

Preview environments vs staging: which to use?

Use both, for different jobs. Staging is the shared, long-lived environment where the whole system runs at its current versions and merged changes are checked together. A preview environment is one pull request’s isolated view before merge, so the change is tested alone and nobody waits for a turn.

Staging environmentPreview environment
LifetimeLong-livedCreated for a change, usually when a pull request opens, deleted when it closes
Shared byEvery team and every merged changeOne change
When testing happensAfter merge, or when a change takes its turnBefore merge, on every push
What a failure meansAny recent change could be the causeThe pull request is the cause
Best forRelease rehearsal, migrations, everything merged togetherTrying each change through the web or mobile app, by people and agents

Teams go wrong when they treat it as a choice. Staging alone becomes a queue: changes wait for a turn, half-deployed work piles up, and failures stop being trusted, which the complete guide to staging environments covers in detail. Previews alone, when each one copies the whole stack, drift from each other and from staging, and the release still meets staging at the end.

The model that works on Kubernetes runs preview environments on the staging cluster. Each preview deploys only the services its pull request changed, and its requests route through those versions while everything else is the staging environment itself. Staging stays the integration point, and every pull request gets its own preview on top of it.

Preview environments on top of staging: each pull request deploys only what it changed, and everything else is the shared staging environment.

How does a preview environment work, from pull request to URL?

A pull request event starts a pipeline that builds the change, creates the environment from a template kept in the repository, and posts how to reach it on the pull request. Closing the pull request deletes it.

A preview can also come earlier. With Signadot, a developer or a coding agent creates one during local development, before any pull request exists: the service being changed runs on the laptop or in the agent’s workspace, everything else comes from the cluster, and the change can be previewed through the web or mobile app while it is still being written.

  1. Trigger. The pull request opens or gets a new commit. GitHub Actions listens for the pull_request event, GitLab runs a merge request pipeline, and Argo CD’s pull request generator polls the repository.
  2. Build. CI builds images for the services the pull request changed and tags them with the commit SHA.
  3. Create. The environment comes from a template kept in the repository: a Helm chart or compose file for a full copy, or a spec that names only the changed workloads for a selective one.
  4. Connect. Ingress and DNS give the preview a URL such as pr-142.preview.example.com, or a routing key carried in a header, a browser extension or a query parameter sends requests to it.
  5. Report. The URL and the test results are posted on the pull request, so review starts from a running system.
  6. Delete. Merging or closing the pull request deletes the environment, and a time-to-live deletes any preview that its pull request abandoned.

The three hard parts are not in that list. They are what each preview copies, what data it sees, and how a request finds the right version of each service. The four approaches below are four answers to those three questions. Per-PR preview URLs, explained covers the URL step for frontends and backends.

The four ways to build preview environments

There are four: frontend-only previews, a full-stack copy per branch, a namespace per pull request built in-house, and selective isolation on a shared cluster. They differ in what each preview copies, which sets its cost, how long it takes to start and how real its dependencies are.

What each approach copies per pull request. The more it copies, the higher the cost and the longer the start.

Frontend-only previews

Vercel and Netlify build the frontend for each branch, deploy it to a unique URL and comment the link on the pull request. Each build is a static or serverless bundle, so a thousand previews cost little more than one. Both have grown past the frontend: Netlify branches a Postgres database for each Deploy Preview, and Vercel has beta support for backend services, containers and queues that keep each deployment’s messages apart. The limit is where they run. A backend made of services on your own Kubernetes cluster is not in the preview, so the frontend calls a shared backend, often staging and sometimes production. That makes frontend platforms right for UI review and for apps built entirely on them, and wrong for a change to a service that lives on your cluster. Pointing a frontend preview at a backend preview closes the gap, which the end-to-end previews with Vercel and Signadot tutorial walks through.

Full-stack copy per branch

Platforms such as Bunnyshell, Release, Okteto, Qovery, Northflank and Shipyard create a complete copy of the application for each branch or pull request by default, usually from a Docker Compose file, Helm charts or the platform’s own environment definition. Each copy gets its own services, databases and queues, typically in a Kubernetes namespace. The mental model is simple and isolation is total: nothing one preview does can touch another.

The cost is linear in two directions. Twenty services and ten open pull requests is 200 running services plus ten of every database and broker, and every preview waits for all of them to start. Data is the other problem: each copy starts empty unless someone maintains seed data, and seed data drifts from the real thing. Full copies fit a handful of services, and they strain as service count and pull request volume grow. A variation, a virtual cluster per pull request with vCluster, gives each preview its own Kubernetes control plane, which is the right tool when a pull request changes operators, CRDs or cluster configuration.

Namespace per pull request, built in-house

Platform teams that run GitOps often build previews themselves: an Argo CD ApplicationSet with the pull request generator stamps out an Application for each open pull request, Helm renders the stack into a namespace named for it, and the generator removes the Application when the pull request closes. Jenkins X, now renamed JayeX, packages the same idea as a preview namespace per pull request. Everything is open source and auditable in Git, and the team controls every detail.

It is a full copy, so it inherits the cost curve above, and the team also owns what a product would handle: cleanup of resources Argo CD does not track (databases, buckets, DNS records), secrets for every namespace, and the pipeline that keeps it all working. ArgoCD preview environments walks through the ApplicationSet pattern and where it strains.

Selective isolation on a shared cluster

Selective isolation copies only what a pull request needs and plugs it into the real environment around it. Signadot is built on it, and its version is the most complete: each preview is an ephemeral virtual environment in one shared environment: the changed workloads are forked onto the existing cluster, and a routing key decides which requests reach them. Requests that carry the key, in an OpenTelemetry baggage header that services propagate from call to call, go to the forked version. Requests without it go to the shared version. A person reaches a preview through a preview URL, the Chrome extension or a query parameter, and a test or an agent sets the header.

You choose how much each preview duplicates. The default copies only the changed services. A preview can add its own database, a topic or other resources when a change needs them, and in the extreme it can copy everything. The changed parts join the application’s flows in three ways: request routing for synchronous calls, message routing for asynchronous and batch work, and configuration that points a service at a new version. What a Kubernetes sandbox is explains the mechanism.

It has requirements. Services must propagate the routing header, which OpenTelemetry instrumentation already does for most stacks. A change that rewrites a shared schema needs its own database for the preview, created by a resource plugin. Consumers of a shared queue need to check the routing key before they process a message. In return, a preview starts in seconds because nothing else has to start, hundreds share one cluster, and every preview runs against the same real services, data and queues as staging. Signadot runs mostly inside your cluster, with a hosted control plane that by default receives only resource metadata, such as workload names, namespaces, image references and status, and never source code or application data, as its data and security documentation describes.

Preview environment platforms compared

This table compares the preview environment platforms buyers evaluate most, grouped by approach. “Not documented” means the vendor’s docs do not describe it, not that it is impossible.

Preview environment platforms compared, October 2026
PlatformWhat gets previewedApproachDatabasesQueues and workflow systemsWorkloads outside KubernetesMonorepo and multi-serviceBest fit
Selective isolation on a shared cluster
SignadotOnly what the pull request needs, from one changed service to the whole stackMany ephemeral virtual environments in one shared environment on your cluster, joined in by request routing, message routing or configurationShared with data kept apart, or temporary databases and Neon or Xata branches through resource pluginsMessage routing on one shared Kafka, RabbitMQ, SQS, Pub/Sub or NATS broker, and routing keys carried through Temporal workflowsResource plugins create managed databases, queues and buckets per preview with Terraform, Helm, a cloud CLI or a scriptSeveral changed services per preview, RouteGroups join pull requests across reposAny application with a backend: dozens to hundreds of services, CI and coding agents
mirrord previewsOnly new or changed services (Enterprise plan)Pods in a shared cluster, scoped by an environment keyDatabase branching for many databasesQueue splitting for SQS, Kafka, RabbitMQ, Pub/Sub, NATS and Temporal, with the queue name in configurationS3 branches, otherwise not documentedNot documentedTeams using mirrord for local development who want previews from the same tool
Okteto DivertOnly the services you deployThe rest from a shared namespace, routed by a baggage headerShared by defaultShared by default, queue isolation is your own consumer code filtering on the headerDeploy and destroy commands in the manifestNot documentedDeveloper namespaces for Okteto users
Frontend platforms
VercelThe frontend per branch and commit, with backends in betaPreview Deployments on Vercel, not on your clusterMarketplace databases, a Neon branch per previewVercel Queues (beta), partitioned by deploymentMarketplace resources onlyA project per directory, unchanged projects skippedFrontend and full-stack JavaScript on Vercel
NetlifyThe site per pull requestDeploy Previews on Netlify, not on your clusterA Netlify Database branch per preview, copied from productionAsync Workloads, preview behavior not documentedNot documentedA site per package, skipping needs an ignore commandStatic sites and frontends
Full-stack copy per branch
BunnyshellThe whole stack in bunnyshell.yamlA namespace per environment, on your cluster or Bunnyshell'sSeeded containers, Terraform, Neon, PlanetScale and Xata connectorsRun as containers or Helm charts in each copyA Terraform component per environmentComponents across repos, a monorepo rebuilds every component by defaultFull copies of multi-repo stacks on your own cluster
ReleaseThe whole stack in an application templateA namespace per environment, in Release's cloud or your AWS or GCPContainers, snapshot-based Instant Datasets, NeonNot documented for previewsTerraform per environmentMonorepo or multi-repo, every service rebuiltAWS and GCP teams that want production-like data
OktetoThe whole manifest per previewA namespace per preview, self-hosted, BYOC or SaaSRestored from volume snapshotsRun inside each copyDeploy and destroy commands in the manifestDependencies across repos, unchanged images reusedKubernetes teams that want dev and preview environments
QoveryA clone of a blueprint environment, trimmable to fewer servicesA namespace in your own cloud accountCloned or shared per preview, cloned without their data and seeded by jobsBlueprints for MSK, RabbitMQ, Redpanda and a Temporal Cloud namespaceTerraform, OpenTofu and CloudFormation through lifecycle jobsA monorepo guide with path rulesA deployment platform on your own cloud account, with previews
NorthflankA preview template per pull request, self-contained or sharing services with devNorthflank's cloud, your cloud or your clusterAddons forked per preview, or a fresh addon and a seed jobA RabbitMQ addon, Kafka and Temporal not documentedOpenTofu nodes, destroyed explicitlyPath rules and a build contextA general Kubernetes platform with templated previews
ShipyardThe whole stack in a Docker Compose fileA full copy per pull request on KubernetesVolume snapshots per named volumeNot documentedNot documentedMulti-repo supportedCompose apps that want hosted full copies
vClusterEverything deployed into a virtual clusterA virtual cluster per pull requestWhatever you deploy inside itWhatever you deploy inside itNot documentedNot documentedChanges to operators, CRDs and cluster configuration
Namespace per pull request, built in-house
Argo CD and HelmThe whole chart per pull requestAn Application per open pull request from the ApplicationSet pull request generatorYou build itYou build itYou build itYou build change detectionPlatform teams that run Argo CD and want to own the system
Jenkins X (now JayeX)The whole helmfile per pull requestA preview namespace per pull request, cleaned up by jx preview gcYou build itYou build itYou build itYou build itTeams already on Jenkins X

Signadot is the most comprehensive preview environment platform in this table. A preview holds only what its pull request needs, from one changed service to the whole stack, on the cluster you already run. Databases, message queues, Temporal workflows and cloud resources are isolated per preview, pull requests across repositories join into one preview, and CI jobs, people and coding agents all reach the same previews. Frontend platforms stop at the frontend. Full-copy platforms pay for the whole stack on every pull request and run queues and workflow engines as more copies. The other selective options cover part of the problem: mirrord’s previews are an Enterprise add-on to a local development tool, and Okteto’s Divert shares databases and queues and leaves their isolation to your own code. For one vendor at a time, see the Okteto alternatives, Release alternative, Qovery alternatives for preview environments, vCluster alternatives for PR environments and mirrord alternative pages.

Which preview environment platform should you choose?

For any application with a backend, choose Signadot. It is the most comprehensive preview environment platform: every pull request gets a preview on the cluster you already run, with real services, databases, queues and workflow engines behind it, isolated where the change needs it and shared everywhere else. You choose how much each preview duplicates, so the same platform covers a one-service change, a change that needs its own database, and a change that needs the whole stack.

The other tools fit narrower cases:

  • A frontend or a static site with no backend of its own: Vercel or Netlify. Their previews are built in, cheap and fast.
  • A few containers that will stay a few containers: a full-copy platform such as Bunnyshell, Release, Qovery or Northflank works, as long as every preview can pay for the whole stack.
  • A platform team set on building its own on Argo CD: an ApplicationSet with the pull request generator and Helm, with a budget for cleanup, secrets, data and maintenance.
  • Changes to operators, CRDs or cluster configuration: a virtual cluster per pull request.

Containers rather than Kubernetes do not change the answer. A small containerized application runs well as a full copy on a platform that builds from a compose file. Once the containers number in the dozens and share databases and queues, copying them per pull request is the expensive part, and the platform that copies only what changed wins on cost, start time and fidelity.

CI/CD workflows that create preview environments

Every working setup has the same four hooks: create on pull request open, update on each push, post the URL, delete on close. What differs is where those hooks live.

  • GitHub Actions: a workflow on the pull_request event for the opened, synchronize and reopened types creates or updates the preview, and the closed type deletes it.
  • GitLab CI: review apps. A job declares a dynamic environment per merge request, a stop job named in on_stop deletes it when the merge request closes, and auto_stop_in deletes previews nobody closed.
  • Argo CD: the ApplicationSet pull request generator creates an Application per open pull request and removes it when the pull request closes, so the hooks live in the cluster instead of in CI.
  • Jenkins: a multibranch pipeline builds each pull request as a branch and calls a CLI to create and delete the environment.
  • Signadot: CI applies a sandbox spec from the repository with signadot sandbox apply. On GitHub, the Signadot GitHub App posts the preview details on the pull request and deletes the sandbox when it closes. On GitLab and Bitbucket, a time-to-live on the sandbox handles teardown. The CI integration docs cover each.

Clean up preview environments automatically

Abandoned previews are the most common cost leak. The cleanup practices that hold up:

  • Delete on the pull request’s close event, not on a schedule alone.
  • Set a time-to-live on every preview as a backstop for missed events and stale branches.
  • Label every resource with the pull request number, so a sweep can find what a failed teardown left behind.
  • Run a periodic job that deletes any preview whose pull request is no longer open.
  • Delete resources outside the cluster, such as databases, buckets and DNS records, in the same teardown that deletes the preview.

Secrets in preview environments

Previews should never receive production credentials. Full copies need credentials for every service in every namespace, usually issued by a secrets manager such as Vault or the External Secrets Operator with a path per environment and short lifetimes. Selective previews reuse the staging environment’s secrets for the shared services and need new credentials only for the resources they create, which shrinks the problem to the parts that changed.

Preview environments for monorepos

Build only what changed and run it as one preview. A monorepo pull request often touches two or three services at once, so the preview has to hold all of them together, and building every service on every pull request wastes most of the CI run.

  • Find the changed services. Path filters in the CI workflow work for a few services. For more, use the build tool’s affected graph: Nx affected, Turborepo filters or a Bazel query.
  • Build those images only, tagged with the commit SHA.
  • Create one preview per pull request, not one per service. The preview holds every changed service, so a change that spans the API and a worker is tested as one change.
  • Share the rest. Unchanged services, databases and queues come from the shared environment instead of being rebuilt.

A Signadot sandbox spec takes a list of forks, so one preview can hold every service a monorepo pull request changed. When a change spans several repositories or several pull requests, a RouteGroup gives those sandboxes one routing key, so they are tested together before any of them merges. A full-copy platform previews a monorepo by copying all of it, which is simple for a few services and slow for many.

Preview environments with databases, message queues and workflow engines

Data and dependencies decide whether a preview is worth opening. A preview backed by an empty database demos nothing, and a preview whose consumer reads every message on a shared queue breaks everyone else’s tests. Each dependency has the same three choices: copy it, branch it, or share it and isolate only what the change touches.

Databases

  • A fresh copy per preview, seeded from fixtures or a snapshot. Full isolation, slow to start, and only as realistic as the seed data.
  • A branch per preview. Databases that branch, such as Neon and Xata, create a copy-on-write branch in seconds. Bitso pairs Signadot sandboxes with Neon branches so a sandbox that needs its own data gets a database branch instead of a full copy of the stack.
  • Share the database, isolate the writes. Most changes read and write rows, not schemas, so the preview uses the shared database with test data partitioned by tenant or account. A schema change gets its own database, created by a resource plugin for that preview only, as database isolation with resource plugins shows.

Message queues

Kafka, RabbitMQ, SQS and Pub/Sub break naive previews because a consumer on a shared topic takes every message. The options are a broker per preview, a topic or queue per preview created when the preview is created, or message routing on the shared broker: the producer puts the routing key in message headers, and each consumer processes only the messages for its version. Message routing keeps one broker and one topic set for every preview. Message isolation for Kafka, SQS and more covers how the pattern maps onto each broker, and the Kafka testing guide goes deep on one.

Workflow engines such as Temporal

Workflow engines add a twist, because workers pull tasks from a task queue rather than receiving requests. With Signadot, the stable worker and the preview’s worker share one task queue, the routing key travels with the workflow in OpenTelemetry baggage, and interceptors on each worker check which version should handle a task, so exactly one version processes it. The Temporal workers tutorial shows it in Python, TypeScript, Go and Java.

Resources outside the cluster

Some dependencies are not containers at all: a managed database, a cloud queue, a storage bucket. Resource plugins create those per preview and delete them with it, using Terraform, Helm charts, cloud CLIs or scripts, and pass connection details to the forked services as environment variables. Services that run outside Kubernetes take part as shared dependencies of the environment, not as per-preview copies.

What AI coding agents change about preview environments

Coding agents turn preview environments from a review convenience into infrastructure that every change depends on. Throughput is up and quality is not keeping pace: the CircleCI 2026 report found average throughput grew 59 percent in a year, the top 5 percent of teams nearly doubled theirs while the bottom quarter saw no gain, roughly 30 percent of merge attempts now fail, and median recovery rose 13 percent to 72 minutes. The teams pulling ahead are the ones whose validation scales with the pull requests their agents open.

Agents are consumers of these environments, not only producers of pull requests, and they use them both ways. An agent’s build, test and fix loop runs automated tests in an ephemeral environment on every iteration, often dozens per change, and between runs it previews the change, driving the web or mobile app ad hoc the way a tester would. Neither can wait for a person to create an environment or for a shared one to be free. A preview that takes 20 minutes to start ends the loop before it begins.

That moves validation ahead of review, and it is what testing AI-generated code in a preview environment means in practice. When Claude Code, Cursor, Codex or Copilot can create a preview, run the change against real services and read the result, it fixes its own failures before a person looks. The reviewer receives a pull request with evidence attached and stops being the test harness.

Isolation has to be per run. Batching several agents’ changes into one shared environment brings back the attribution problem staging has: when the batch fails, nobody knows which change caused it, and every agent retries. Each run needs its own preview.

Cost and cleanup have to be automatic. Hundreds of concurrent previews are affordable only if each one copies little, and only if every one has a time-to-live, because agents abandon work more often than people do.

The path an agent takes matters as much as the environment. With Signadot, an agent creates a sandbox through the CLI or the MCP server, connects its local run to the cluster with a local sandbox, and runs the checks the validate skill defines. Validating AI-generated code against real Kubernetes dependencies covers the full loop, and scaling coding agents in enterprise Kubernetes covers what changes at hundreds of agents.

What do preview environments cost at scale?

Cost is what each preview copies, times the number of previews open, times how long they live. A full copy costs the number of services times the number of open pull requests. A selective preview costs only the changed services times the open pull requests.

Take 40 services and 30 open pull requests, each changing two services. Full copies run 1,200 service deployments plus 30 of every database and broker. Selective previews run 60 deployments on one shared environment. Spin-up time follows the same curve: when a full copy of 40 JVM services takes 15 minutes to start, the fix is starting fewer services, not faster ones.

The numbers hold up in practice. Brex saves about $2 million a year in infrastructure after replacing its homegrown full-copy preview environments with Signadot, and its engineers report deploys of under five minutes against the 30 to 60 minutes the old previews took. Bitso replaced a homegrown system that duplicated 200 services, about 100 databases and 20 caches for every pull request. Reducing costs with Kubernetes ephemeral environments works through the cost model in more detail, and cost-efficient preview environments in Kubernetes shows the setup step by step.

Preview environment best practices checklist

  • Does every pull request get a preview automatically, with no ticket and no request?
  • Is the preview created from a template kept in the repository, reviewed like code?
  • Does the preview hold every service the pull request changed, and only those?
  • Does it run against real versions of the services it depends on, not mocks?
  • Does each preview have realistic data, through shared data with isolated writes, a branch, or maintained seed data?
  • Do consumers of shared queues and workflow task queues process only their own preview’s messages?
  • Are the URL and test results posted on the pull request?
  • Can a person reach the preview from a browser and a test reach it from CI by the same key or URL?
  • Is the preview deleted when the pull request closes, with a time-to-live as a backstop?
  • Does every preview get its own short-lived credentials, never production secrets?
  • Can a coding agent create a preview by CLI or API in seconds, without a person?
  • Do you know what a preview costs, and does that cost grow with the changed services rather than the whole stack?

Where to go next

If you are choosing a platform, start from the comparison table above and the Kubernetes preview environments page for how Signadot does it. If your previews already exist and cost or start time is the problem, read the cost section and the isolation models comparison. If coding agents are the reason you are here, go to the guide to validating AI-generated code.

Frequently asked questions

What is a preview environment?

A preview environment is a temporary, isolated environment created for a change, usually automatically for each pull request, so a person or a coding agent can try it through the application's web or mobile front end before it merges. Developers and agents can also create one during local development, before a pull request exists. Teams also call it a PR environment or a pull request environment.

Should we use preview environments or a staging environment?

Most teams need both. Staging is the long-lived environment where the whole system runs at its current versions and merged changes are checked together. A preview environment is one pull request's isolated view before merge, so the change is tested alone and nobody waits for a turn. On Kubernetes, preview environments can run on the staging cluster itself, deploying only what each pull request changed.

What is the difference between preview environments and ephemeral environments?

Every preview environment is an ephemeral environment, but ephemeral environments do more. A preview is manual testing through the web or mobile front end, by a person or by a coding agent exploring the change ad hoc. The same ephemeral environment also runs automated frontend, backend, functional, security and performance tests from CI or an agent's loop. Signadot provides ephemeral environments, so previews and automated tests share one environment per change.

What are the best platforms for preview environments?

For any application with a backend, Signadot is the most comprehensive preview environment platform. Each preview holds only what its pull request needs on the cluster you already run, with databases, message queues, Temporal workflows and cloud resources isolated per preview, and the same previews serve CI and coding agents. Vercel and Netlify cover frontends. Full-copy platforms such as Bunnyshell, Release, Qovery and Northflank suit a handful of services.

How do you create a preview environment for every pull request?

Trigger it from the pull request. A CI workflow on the pull request event builds the changed images, creates the preview environment from a template kept in the repository, posts the URL on the pull request, and deletes the environment when the pull request merges or closes, with a time-to-live as a backstop. GitHub Actions, GitLab CI, Jenkins and Argo CD's pull request generator all support this pattern.

Do preview environments work for monorepos?

Yes, if each preview environment builds only what the pull request changed. Path filters or a build tool's affected-project graph, such as Nx, Turborepo or Bazel, find the changed services. CI builds those images and creates one preview per pull request that runs them together against everything else. Copying every service in the monorepo for each pull request works for a handful of services and gets slow and expensive beyond that.

How do preview environments handle databases and message queues?

There are three choices for each dependency. A preview environment can run its own fresh, seeded copy, branch the data per pull request with a tool such as Neon, or share the existing database and broker and isolate only what the change writes or consumes. For queues, sharing means message routing: the routing key travels in message headers and only the preview's consumers process its messages.

What do preview environments cost at scale?

Cost follows how much each preview environment copies. A full-stack copy costs roughly the number of services times the number of open pull requests. A selective preview costs only the changed services times the open pull requests, usually a small fraction. In its published case study, Brex reports saving about $2 million a year in infrastructure after replacing full-copy previews with Signadot. Deleting on close and a time-to-live keep abandoned previews from piling up.

How do AI coding agents change preview environment requirements?

Agents raise both the number of pull requests and the number of attempts per change. A build, test and fix loop needs a preview environment on every iteration and cannot wait for a person to provision one. Previews for agents have to be created by API or CLI in seconds, isolated per run, cheap enough to run hundreds at once, and deleted automatically when the run ends.

Can a coding agent test its change in a preview environment before opening a pull request?

Yes. Agents such as Claude Code, Cursor, Codex and Copilot can call a CLI or an MCP server to create a preview environment that holds only the services they changed, explore the change through the web or mobile app, run automated tests against the real services and data around it, and fix the change before a person reviews it. The pull request then arrives with evidence that the change works, not only a diff.

Stay in the loop

Get the latest updates from Signadot