Fast by Construction: Shipping New Platforms in a Fraction of the Time
This month we put a new product into production. Clarado is a sanctioned-entity identification service: give it a name, it checks the global watch lists, and returns a clear answer with a record you can show an auditor. The useful part of this story is not what Clarado does. It is how little time it took to get there, and why.
The honest reason is not talent or long nights. It is that most of what a serious platform needs was already built, already running, and already trusted. Clarado did not start at zero. It started most of the way home.
The slow way: every platform rebuilds the same plumbing
Strip away the product idea and almost every serious platform needs the same scaffolding before it can do anything interesting:
- Identity — who is this person, and are they allowed to do this.
- Notifications — tell the right people when something happens, by email or message.
- Storage — keep files and data safely, and hand them back on demand.
- Monitoring — know the system is healthy, and know first when it is not.
- Audit — keep an honest record of what happened and who did it.
None of it is the product. All of it is required. A team that builds this from scratch spends months on plumbing before the first real feature exists, and then maintains that plumbing forever. That is where the years go.
The shared spine: build the foundation once
We built that scaffolding one time, as a set of shared services that every RCI product uses. Identity, notifications, storage, monitoring, reporting and an audit trail all run as their own small, hardened services. A new product does not rebuild them. It plugs in.
So a new build starts from a very different place. The foundation is already there, already in production, already watched. What is left to build is the part that is actually new: the thing that makes the product worth having.
What you can plug into today
Every one of these is a shared service a new product reuses instead of rebuilding:
- Identity and SSO — one login across products, federated to a customer's own directory.
- Secrets — encrypted secret storage with rotation and an audit trail.
- Notifications (FARO) — email and WhatsApp with templates and scheduling.
- File storage (Vault) — shared files with secure links and quotas.
- Backups (Stash) — backup coverage and freshness across the fleet.
- Monitoring — health checks and tiered alerts across services.
- Analytics (Usher) — cookieless web analytics, no personal data.
- Documentation — shared docs, runbooks and guides.
- Policies — canonical policies and compliance records.
- Diagrams — architecture diagrams rendered from text.
- Project tracking — goals, milestones and tasks with an API.
- Error reporting — in-browser bug capture with screenshot and logs.
- The tamper-evident ledger — append-only, signed history any product can adopt.
And larger platforms, for whole problem domains: Aura, Themis, Data Bastion, OXBO-X, OCR by Consensus and Legajos.
The proof: Clarado, from idea to product in days
Clarado is what this looks like in practice. Logging in, sending alerts, storing data, staying healthy, keeping an audit trail — none of that was written for Clarado. It came from the spine. The team's real work was the part only Clarado needs: the matching engine that compares a name against the watch lists and decides clear, review, or blocked, and the record that proves what it decided.
That focus is why it reached production quickly, and it is already checking real transactions for a real business. See it live at clarado.roderickc.com.
The differentiator: a ledger in the foundation
Most of the spine is the kind of thing any good team can build given enough time. One part is not. Every RCI product writes its important events to a tamper-evident ledger: an append-only record with a signed chain, so no entry can be quietly changed or removed after the fact. Who was checked, what was decided, what was accessed, what changed — all of it provable later.
Most teams bolt this on late, when a regulator or a customer finally demands it, and it is painful every time. We put it in the foundation. So every product we build is auditable the day it launches, not the year after. For work where trust is the product — sanctioned-entity identification, compliance, regulated operations — that is the difference between a demo and something a serious buyer will actually run.
What this means for you
When a customer comes to us with a platform to build, they are not starting a multi-year project. They are adding the part that is theirs on top of a foundation that already works. That means a working system sooner, a smaller bill for the plumbing nobody wants to pay for twice, and, from the first day, a product that can prove what it did. Fast to build, and honest by design. That is the whole idea.