Miro’s AI product team adopted Signadot to build and test a brand new AI architecture, and now relies on it as the runtime validation layer behind their agentic development workflow, from testing the internal tools their agents use to validating agent-generated code against live dependencies and traffic.
Adoption has since spread across Miro’s engineering org, where Signadot is enabling them to consolidate environments, accelerate pull request validation, increase integration test coverage, and retire legacy infrastructure that had been a target for years.
“Our engineers were spending more time waiting for an environment than shipping. Now they test against our real services in parallel, which made a whole tier of fixed test infrastructure unnecessary. Retiring environments we had carried for years is projected to save us several million dollars annually.” Jony Jeyaratnam · Head of Engineering, Miro
Miro is the AI Innovation Workspace used by more than 100 million users and 250 thousand organizations worldwide. Their team of 500+ engineers runs nearly 250 microservices across 70+ teams on a stack that has been migrating from an EC2-based monolith to Kubernetes and Istio, with GitOps delivery through Argo CD, plus Kafka, Temporal, and gRPC/HTTP services and OpenTelemetry-based tracing.
Miro’s engineering org carries the weight of a large, stateful, distributed system. A monolith historically ran outside Kubernetes on EC2, microservices depend heavily on shared state across databases, queues, and streaming, and the whole estate was mid-migration onto Kubernetes and Istio. Testing any non-trivial change meant exercising a lot of moving parts together.
The AI platform team felt this most acutely. They were standing up a brand new AI architecture under deadline pressure, and their existing options for testing it were all dead ends. Running the full stack locally was impractical, mocking dependencies did not reflect reality, and the only shared environment for integrated testing was a single contested slot where work collided constantly.
“We’d be competing for the same slot and overlapping our changes with other people’s changes. Sometimes that led to confusion. I was testing my changes, but now they’re not there anymore, what happened? Someone else had pushed to the same environment.” Tiago Pereira · Staff AI Engineer, Miro
Developers were overwriting each other mid-test, with no way to work in parallel. The same contention capped testing across the wider org. With twelve environments for the monolith’s end-to-end tests, each carrying multiple profiles that had to be kept in sync, only twelve integration sessions could ever run at once. Every other pull request queued.
When the Miro team first tried Signadot, the value registered immediately.
“Once the team understood what Signadot could do, the conversation went from ‘No, we don’t have time to try that now.’ to ‘Oh, hang on, that would really help us. Can we try it straight away?’” Andrew Eacott · Senior Principal Engineer, Miro
In a hands-on technical evaluation, the team worked through how Signadot’s routing coexists with Argo CD and GitOps, how it forks workloads behind an Istio mesh, and how to handle their heavy reliance on state. Resource plugins covered the stateful and out-of-cluster cases, including the EC2 monolith, and confirmed Signadot could slot in without fighting their existing deployment tooling.
Implementation went deeper than individual developers spinning up environments. The AI platform team built native support for Signadot sandboxes into the administration layer of their internal platform, including tool registration. Then Miro’s DevEx team wrapped Signadot in an internal CLI so developers across the org could work with it easily.
They also extended support to Temporal and Kafka on top of standard gRPC and HTTP RPC, and added custom WebSocket handling through their own RPC gateway.
“From a technical point of view it was fine. You need all the consumers to collaborate on what an environment means in terms of a Kafka topic or a Temporal queue. So it was more of a change management process than a technical challenge.” Andrew Eacott · Senior Principal Engineer, Miro
Signadot’s central role at Miro spans two sides of the same AI workflow. The team is building agentic features, and it is using coding agents to build them. Signadot is the runtime validation layer for both.
The first side is the tools its agents use. Miro runs an internal platform where developers build those tools, and as they experiment with prompts and new functionality, they test each iteration against real downstream services through Signadot, rather than against mocks.
“We rely heavily on Signadot to test new iterations of tools as we experiment with prompts and new functionality. We’ve really built that into our ways of working.” Dominic Hauton · Lead Engineer, Miro
That is one of the core use cases on the AI stream and a standard step in how the team ships. The second side is letting coding agents validate their own work.
To lower the barrier to entry, their team wrote internal skills that teach coding agents how to generate an environment spec from a developer’s microservice or from the monolith. For engineers new to Kubernetes, having an agent craft the spec removes a real learning curve. Dominic’s team then integrated those skills into a new project so agents can stand up entire multi-service test environments on demand.
“You can say, ‘Claude, please set up the infrastructure and run this evaluation to see if the agent can solve this problem given the changes I’ve made in my microservice.’ So we can iterate purely agentically, using Signadot routing to orchestrate that full end-to-end test.” Dominic Hauton · Lead Engineer, Miro
The key is that the loop is closed. The agent does not just generate code and hand it off for manual verification. It exercises the change end-to-end, against live traffic, and iterates until it works.
“We’re able to get Cursor to launch a full test environment and use the browser to actually press buttons, type an agentic prompt, and test that full end-to-end flow using the Signadot-deployed versions of the services.” Dominic Hauton · Lead Engineer, Miro
Without Signadot, this workflow collapses. The only alternative is deploying to actual staging, where one developer can hold a service at a time, capping concurrency to a single agent. With Signadot, each agent gets its own environment, so many can iterate in parallel against a realistic, production-like system and deliver validated code before a pull request is ever opened.
This is exactly the direction Signadot is investing in. Since Miro built its internal skills, Signadot has expanded its own agent-native tooling with the signadot-validate skill, which enables coding agents to validate changes autonomously, and Signadot Plans, reusable validation workflows that platform teams govern and agents compose. The Miro team is exploring folding both into its workflows going forward.
Removing staging contention was the unblock the AI team needed. Developers now link the deployed client to their own local backends, run their changes in parallel, and merge when ready, with no overlap. The same model scaled outward. The content management team replaced their entire end-to-end testing setup by running integration tests in ephemeral environments and in CI, iterating far faster than the difficult prior arrangement allowed.
The largest structural win is the monolith. By consolidating roughly twelve fixed environments into one and spinning up on-demand resources inside ephemeral environments, Miro is lifting the ceiling on how many changes it can validate at once.
“We had twelve environments, which means we could only run twelve concurrent integration sessions, so any other PRs would queue. With Signadot we can essentially 10x that at high peak. That’s more code processed faster.” Daniel Stanoescu · Principal Engineer, Miro
For microservices pull requests, developers spin up shareable environments quickly enough that an engineer can hand a change to a product manager for review almost immediately. And the capability finally let Miro turn off infrastructure it had been paying for without using.
“This is the lever that lets us deprecate old environments we’ve had lying around for years and couldn’t turn off. I’ve been at Miro for four years, and it’s been a pain point that whole time. Without this, we wouldn’t have been in a position to save that money.” Andrew Eacott · Senior Principal Engineer, Miro
Miro’s story shows what runtime validation unlocks for an AI-native engineering org. The same capability that lets developers test agent tools against real dependencies lets coding agents verify their work, and lets every team ship microservice and monolith changes in parallel rather than one at a time.
Signadot has become a vital layer in how Miro builds its AI products and how it ships code with agents at scale, turning a stateful, distributed system that once forced work into a single queue into one where many people, and increasingly many agents, build and validate at the same time.
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
