Routebase: One Living Spec for Docs, Mocks & Tests

I kept running into the same failure mode: your API contract doesn’t live in one place. It’s split across design tools, documentation portals, mock servers, contract tests, and monitoring dashboards. Each copy changes on its own schedule, so the “real” contract slowly diverges from what consumers think it is.

That drift is where bugs hide, and it’s also why fixing a single tool rarely helps. If the pain happens between tools, then the contract needs to become the shared artifact that every step references—design, docs, mocks, tests, and monitoring—so they stop guessing and start validating against the same version.

Routebase is my answer to that problem: one living source derived from a visual OpenAPI editor, where publishing a spec version generates the docs portal and mock server, and where tests and monitors validate live responses against that same version. The result is a pipeline that behaves like code review: change the contract once, then catch drift before consumers do.

Most API teams don’t actually have an “API source of truth”—they have multiple representations of the same contract. The OpenAPI file is edited in one place, the docs portal gets updated later, the mocks get adjusted when someone remembers, and the contract tests often lag behind the latest changes.

When a field changes in production, the failure typically shows up somewhere downstream: a frontend team sees an unexpected payload shape, a QA run passes against an older contract, or monitoring notices too late. Even when each tool is correct in isolation, the overall system breaks because the contract versions aren’t aligned.

There’s also a workflow mismatch. Engineers want to treat changes like code—branch, review, and merge—while many API documentation and testing workflows are copy/paste oriented. The contract becomes hard to review, hard to validate consistently, and easy to accidentally ship with breaking changes.

Routebase keeps your API lifecycle anchored to one living OpenAPI spec. You design the contract in a visual OpenAPI editor (or import the spec you already have), then publish a version. From that published version, Routebase generates the docs portal and mock server, and it uses the same version for contract tests and drift monitoring.

The practical outcome is that changes don’t propagate by manual updates across tools. They propagate by publishing. When you change the contract once, the docs, mocks, test suites, and monitors follow in a single publish, so you can validate what’s real against what you intended.

Routebase also focuses on the “between tools” gap: it replays live responses against the published spec and flags divergences with field-level diffs. Instead of waiting for a consumer to report a mismatch, you get a concrete diff showing what drifted and where.

Finally, Routebase makes the spec usable by agents. Each workspace ships a built-in MCP server, so AI agents can read and act on the same source of truth—designing endpoints, running test suites, and linting specs—under your team’s permissions, without glue code.