Bitso, a leader in digital financial services in Latin America, spent years trying to solve the shared staging problem. With 200+ microservices, ~100 databases, and 250+ engineers all pushing changes into the same environments, something was always broken. Their homegrown preview environments solution required replicating the full stack per PR. This was already too expensive and too unreliable to sustain at scale, and then coding agents quickly made it impossible.
Signadot gave them a different model. Instead of duplicating environments, Bitso now forks only the changed services per PR and routes traffic through a single, stable cluster. This became the foundation of an internal initiative the team calls RISE (Robust Isolated Staging Environment), consolidating four fragile environments into one.
As AI coding agents have driven a surge in the volume of changes flowing through the pipeline, this architecture has proven essential, giving Bitso the validation infrastructure to keep shipping safely at a pace that would have overwhelmed their previous setup.
Bitso’s platform is built on roughly 200 Java Spring Boot microservices communicating over gRPC, ~100 Postgres databases, 20+ Redis caches, and asynchronous messaging across Kafka, SQS, and Redis Streams. It is not feasible to run this stack locally. Engineers and their coding agents depend on remote environments to validate their work.
As the team scaled to over 250 engineers and adopted agentic coding tools across the organization, that dependency became a bottleneck. Bitso maintained four separate non-production environments, each with varying degrees of stability, and none of them delivered the confidence engineers needed to ship with speed.
The core problem was contention. Hundreds of engineers were pushing changes into shared environments where one faulty deployment could break the pipeline for everyone. The development environment was built around an unprotected branch that any engineer could push to directly.
Coding agents compounded the problem. Over the past year, the number of PRs flowing through the pipeline per developer increased by 60%, adding load to their testing infrastructure that was already bottlenecked.
The deployment process compounded the problem further. Engineers and agents would deploy changes to staging, where they mingled with other people’s changes, and then deploy a separate build to production. The code running in production was never identical to what had been validated in staging.
Bitso’s vision was clear: collapse down to a single stable non-production environment where engineers and their agents could validate changes in isolation without stepping on each other. They needed infrastructure that could provide isolation at the scale of their architecture, and at the velocity of agentic development, without replicating it entirely.
Signadot’s lightweight ephemeral environments gave Bitso the next step forward: per-PR sandboxes that fork only the changed services while routing traffic through a stable shared cluster. Instead of replicating the entire environment, Signadot uses routing keys to direct traffic to only the modified services, with all other dependencies served by the stable cluster. This approach spins up in seconds rather than minutes and costs a fraction of full-environment duplication.
Because each PR gets its own isolated environment automatically, the system scales linearly with the increase in changes flowing through the pipeline. There is no shared environment to bottleneck, no queue of developers waiting to deploy to staging. This was critical for Bitso as agent-driven PRs increased the volume of changes far beyond what shared environments could absorb.
Critically, this also unlocked artifact promotion.
Bitso formalized this new architecture under an internal initiative called RISE: Robust Isolated Staging Environment. The architecture pairs Signadot for compute-layer isolation with Neon for data-layer isolation, providing instant Postgres database branches per sandbox for services that require schema changes or write-heavy testing. The combination gives engineers and agents production-like fidelity without resource contention.
Signadot has become a core part of Bitso’s agent workflows. All affected services within a PR receive a sandbox automatically, and some services have either deterministic integration tests or custom agent skills that validate the behavior of those sandboxes. The result is a tighter feedback loop: agents generate code, Signadot provisions the isolated environment, and validation runs against it before the change is merged.
Looking ahead, the team is exploring Signadot’s Plans feature, which provides agent-native validation workflows purpose-built for the inner loop, giving coding agents the ability to validate their own work inside sandboxes before a PR is published.
As Bitso adopted coding agents across the organization, a pattern emerged. The agents could generate large volumes of code and clear the cheap checks on their own (unit tests, lints, and mocked dependencies), but anything beyond that had to be handed back to engineers. In a system of 200+ interdependent microservices, the behavior that actually matters only shows up when a change runs against real services, real data, and real messaging. Mocks cannot represent that, so the agent’s work stalled at the point where a human had to take over and validate it in a shared environment.
Signadot enabled Bitso to move more of that validation surface into the inner loop for their coding agents. Using Signadot’s local development capabilities, an engineer or an agent can run the service being changed locally and connect to the staging cluster for every other dependency, without the sidecar overhead or deployment restarts that came with Telepresence, which they were using previously. The agent gets the same routing keys, isolation model, and sandbox infrastructure that drives per-PR validation in CI, which means it can exercise its change against realistic dependencies as it writes it.
The effect is a tighter, more realistic feedback loop. Instead of generating code, clearing only the shallow checks, and handing off, agents can validate against production-like behavior before they open a PR. More of the work arrives already validated, and engineers spend less time confirming what the agent could have confirmed itself.
Since launching RISE and adopting Signadot alongside AI-assisted development and broader developer platform investments, Bitso has seen dramatic improvements across their key engineering velocity and quality metrics:
These gains reflect the combined impact of Signadot, AI coding agents, and broader platform investments. But the relationship between these factors is reinforcing, not incidental. Coding agents drive velocity. Signadot provides the validation infrastructure that makes shipping at that velocity safe.
The change failure rate improvement is especially striking. Even as deployment frequency more than doubled, incidents dropped from 5.2% to 0.9% across all severity levels (P4 through P1). Per-PR isolation means engineers and agents catch problems before code reaches the shared cluster, rather than discovering them in production.
Signadot gave Bitso isolated validation across a complex distributed architecture, at the velocity that coding agents demand. Agents and engineers can test changes against realistic dependencies in the inner loop before a PR exists, every PR gets its own sandbox automatically in CI, and the exact artifact that was validated is what ships to production. The result is a team that ships more than twice as often, with a fraction of the failures, on a foundation built to scale with the next wave of agentic development.
To see how lightweight ephemeral environments can work for your team, sign up for free or book a demo.
Get the latest updates from Signadot
