GitLab Review Apps let you deploy a code change to multiple environments such as Kubernetes, Heroku, FTP, and more, enabling real-time testing before merging. This flexibility supports diverse CI/CD workflows across cloud, on‑premises, or hybrid infrastructures.

Multiple Choice

What types of environments can GitLab Review Apps be deployed to?

GitLab Review Apps provide the functionality to deploy applications to various environments that facilitate testing and validation of code changes in real-time before merging them into the main branch. This capability allows teams to review changes in an isolated environment, which is essential for Continuous Integration/Continuous Deployment (CI/CD) workflows. The correct choice indicates that Review Apps can be deployed not just to Kubernetes, but also to other platforms like Heroku, FTP, and more. This versatility supports a wide range of deployment strategies across different types of infrastructures, whether they are cloud-based, on-premises, or hybrid. By supporting multiple deployment options, GitLab allows teams to choose the environment that best fits their needs and existing infrastructure. Kubernetes is a popular choice due to its orchestration capabilities and scalability, but limiting deployments to only this platform would restrict the flexibility needed in diverse development environments. Similarly, local servers and cloud-only options would not cover the full range of possible deployment scenarios, making the chosen response the most comprehensive and accurate in reflecting GitLab Review Apps' capabilities.

Review Apps: Turning Code Changes into Real-World Demos

If you’ve ever pushed a new feature and wondered, “How will this actually behave in the wild?” you’re not alone. Modern software teams crave a quick, trustworthy way to test changes in an environment that mirrors production without postponing feedback. That’s where GitLab Review Apps come in. They’re like tiny, throwaway stages that spring up automatically for every merge request, giving you a living, breathing preview of how a feature behaves with real data, real users, and real dependencies. And crucially, they aren’t tethered to one single platform. They’re designed to be as flexible as your infrastructure needs them to be.

A quick map of the terrain: what Review Apps are, in plain language

Think of a Review App as a temporary deployment. When you create or update a merge request, GitLab can spin up a dedicated environment that hosts your application just as it would run in production. It’s not a one-size-fits-all demo; it’s a dedicated slice of your stack where stakeholders—engineers, product folks, QA, and even curious designers—can poke around, log in, and validate behavior before any code lands in the main branch.

The beauty here isn’t just about the glass-smooth deployment. It’s also about the feedback loop. You can test UI flows, API interactions, authentication, and integrations with third-party services in isolation. No more guessing if a change will break something down the line. You see it, you confirm it, and you iterate quickly. It’s a workflow that aligns nicely with continuous integration and continuous deployment rituals, where speed and reliability go hand in hand.

Where can Review Apps actually live? A tour through deployment destinations

One of the most appealing aspects of Review Apps is their versatility. The platform isn’t wed to a single hosting or orchestration technology. Instead, it supports a spectrum of environments that teams may already be using—or exploring—across their pipelines. Here’s a sense of what “deployment destinations” can look like in practice:

  • Kubernetes clusters: This is a natural fit for many teams. Kubernetes offers robust orchestration, automated rollouts, scaling, and isolation. A Review App deployed to Kubernetes gets the flavor of a production-grade cluster, including namespaces, ingress rules, and service discovery. It’s especially handy when your production environment already runs on Kubernetes, ensuring parity in networking and resource management.

  • Heroku and other PaaS options: For teams that prefer a Platform-as-a-Service approach, Heroku or similar platforms provide a streamlined path to deployment. These environments abstract away much of the underlying infrastructure, letting developers focus on code and config rather than server management. Review Apps on Heroku can be a great way to validate features in a managed environment with predictable behavior.

  • FTP and traditional hosting avenues: Yes, even older or more basic hosting setups can participate in the Review App process. If your stack includes FTP-based deployments or conventional shared hosting, you can still surface a dedicated preview for every merge request. This approach can be especially valuable for teams maintaining legacy systems or slower-moving infrastructure.

  • Other cloud and hybrid scenarios: The real strength here is flexibility. Cloud VMs, private clouds, on-premises containers, or any combination of these can host Review Apps. The goal is to mirror your real-world deployment surface just enough to catch issues early, without forcing you into a single, predefined path.

Why this multi-destination capability matters

You might wonder why it matters that Review Apps aren’t limited to one platform. Here are a few practical reasons to care:

  • Aligns with existing infrastructure: Most teams don’t operate in a vacuum. Some pieces live on Kubernetes; others on Heroku; a few critical components push to an FTP-based host for compatibility with legacy systems. Being able to deploy previews across a mix of destinations means you don’t have to re-architect your stack to test new code.

  • Reduces risk in edge cases: Some features only reveal their quirks under certain environments—like how a microservice behaves when network latency climbs, or how a feature toggles with specific configuration files. Seeing these behaviors in multiple contexts helps surface corner cases before they turn into surprises in production.

  • Encourages collaboration: Designers want to see real flows; backend engineers want to validate API behavior; QA wants end-to-end sanity checks. When you can preview in environments that match each stakeholder’s expectations, conversations become more concrete and decisions come faster.

  • Supports gradual migration and experimentation: Teams are often exploring new architectures or hosting strategies. Review Apps that can land in different stacks enable experiments without committing to a single direction too early.

The practical side: what you’ll experience in a real world workflow

Let’s walk through a typical scenario, not as a rigid script, but as a natural rhythm you might recognize in your daily work.

  • A feature gets to a merge request: A developer introduces a change and opens a merge request. Your GitLab runner triggers CI, tests run, and the code is ready for review. The magic moment arrives when a Review App is created.

  • Preview in action: A dedicated environment pops up. You can visit a URL that’s unique to this change and environment. It’s a clean slate where you can test real interactions—log in to a staging instance, try a new checkout flow, or validate a payment integration against a sandbox.

  • Cross-environment checks: If you’re curious how a feature behaves in a Kubernetes-backed service mesh, you switch to that Preview App. If you want a faster, more lightweight test on Heroku, you can pull that lever too. Each destination mirrors a slice of the overall ecosystem, giving you a mosaic view of how things behave together.

  • Feedback loop: Stakeholders click through, report issues, and request tweaks. The team iterates by pushing updates to the branch, watching the corresponding Preview App update, and validating again. It’s a kind of dialogue between code and context.

  • Cleanup and continuity: Once the merge request matures, and changes land in the main line, the Preview App for that MR is torn down automatically. The environment isn’t left hanging around to clutter resources; this keeps things tidy and predictable.

Tips for getting the most out of Review Apps across environments

  • Start with the most shared paths: For many teams, the critical user journeys run through a handful of services or pages. Make sure those paths are tested consistently across the platforms you care about.

  • Keep configurations clear and portable: Environment-specific settings can cause surprises. Use configuration patterns that stay readable across destinations—think environment variables, feature flags, and clearly scoped deployment scripts.

  • Monitor in-context: It’s not enough to deploy; you need observability. Bring in lightweight monitoring and logging that’s visible from the preview environment. If something goes wrong, you’ll want to see traces, errors, and performance signals in one place.

  • Communicate the reality of the environment: A Preview App should feel like a real instance, but it isn’t production. It’s important to document any constraints or differences so teams interpret results correctly. That clarity saves misinterpretations and back-and-forth.

  • Embrace the hybrid mindset: Don’t lock yourself into one routine. If your org is gradually transitioning to a more containerized world, Review Apps give you a safe harbor to test the waters across platforms without slowing down the rest of the team.

A few caveats to keep in mind

No tool is perfect, and Review Apps aren’t a magic wand that fixes every deployment hiccup. A few reality checks help you stay grounded:

  • Resource awareness: Spinning up multiple previews can chew through compute and storage. It’s smart to set sensible limits, especially for long-running previews or for projects with a high volume of merge requests.

  • Security considerations: Each Preview App represents a live environment. Make sure access controls and data handling are appropriate for the level of visibility you’re granting, particularly for features that involve sensitive information.

  • Consistency across platforms: While the flexibility is fantastic, it can also introduce variance. Document any platform-specific quirks and ensure your testing covers critical flows in all relevant destinations.

Harvesting the best from a flexible Preview strategy

If you embrace the multi-platform capability of Review Apps, you’re choosing a path that mirrors the real world: varied environments, different constraints, and a shared goal of delivering solid software faster. The ability to preview changes not just on Kubernetes but also on Heroku, FTP, and beyond means you can align each feature with the right context. Some teams lean into Kubernetes for production parity and use a lighter path for quick edit-and-verify cycles on a PaaS. Others shade toward hybrid setups where on-prem components meet cloud services in the same workflow.

The key is to stay curious and practical. Allow previews to inform design decisions as early as possible. Let product, design, and engineering talk through what a feature feels like in a real session, not a pretend sandbox. When you couple that with reliable automation, you create a cadence that’s as much about learning as it is about shipping.

A quick word on the bigger picture

Review Apps aren’t just a deployment feature; they’re a practical philosophy about how teams collaborate around code. They encourage empathy for the end user’s experience, not merely a technical checkmark. They invite stakeholders to see changes in motion, to question how new interactions fit into existing flows, and to catch issues before they ripple out into production. It’s a rhythm that respects both speed and care—a balance that modern software teams chase with varying degrees of success, but which becomes more achievable when you downshift into tangible previews.

What it means for you

If you’re exploring GitLab in a professional setting, you’ll find the ability to host Review Apps across Kubernetes, Heroku, FTP, and other platforms to be a real productivity boost. It reduces back-and-forth, clarifies assumptions, and helps everyone stay aligned on what “done” looks like for a given feature. And because Preview Apps are tied to each merge request, you’re always looking at the most relevant snapshot of the codebase—the exact version that’s under consideration, with its own context and history.

So next time you push a change, picture a tiny, purpose-built home for that code. Imagine a dedicated space where you can walk through the user journey, poke at edge cases, and witness how the system behaves with fresh data. That’s the essence of Review Apps: a practical, flexible way to test and validate in a living, breathing environment. It’s not about choosing one path; it’s about choosing the right path for the situation—and letting the code tell you what it needs.