Skip to content
Cinnabar / Build

SaaS product engineering. The wedge.

Build is the door most partnerships walk in through. Multi-tenant platforms, billing, dashboards, integrations, and the operational scaffolding modern software needs to last — engineered by a small senior team, designed to be inherited.

Why we lead with it

The shape of the work we know best.

Most of our partners arrive with a product instinct that's been validated somewhere — a working prototype, a single happy customer, a manual operation that wants to become a platform. Build is the practice that turns that instinct into something durable enough to bet a company on.

We treat SaaS product engineering as the wedge of the studio because it's the discipline where the rest of our craft compounds: design, applied AI, and platform engineering all show up inside a real product. When the build is right, the other three follow naturally.

Engagements run nine to eighteen months with a small senior team — typically five to seven contributors, all of whom have shipped real systems at scale before. We embed deeply, ship in weekly cadence, and stay long enough that the platform is genuinely owned by your team.

Services

What a Build engagement covers.

  • Greenfield SaaS platforms

    Zero-to-forty product builds for teams who've validated the wedge and need to ship something durable. Multi-tenant from day one, with the operational scaffolding that turns a working product into a working business.

  • Multi-tenant architecture

    Tenant isolation at the database, application, and identity layers. Sensible blast-radius boundaries; per-tenant encryption keys where they earn their keep; row-level security as a default rather than a retrofit.

  • Billing & entitlements

    Subscription, usage-based, and hybrid pricing models. Stripe and Stripe Connect, with a real entitlements layer your product team can change without a deploy. Audit trail, proration, and revenue-recognition built in.

  • Admin & internal tooling

    The internal surface that decides whether your team can operate the product they've built. Customer admin, debugging tools, support workflows, feature flags — built with the same care as the customer-facing surface.

  • Migrations & re-platforms

    Replacing a system in flight, without customer-visible downtime. Parallel architecture, customer-by-customer cutover, eval-style consistency checks for as long as both systems run side-by-side.

  • Integrations & API surface

    Public APIs, webhooks, and the partner ecosystem on top. Designed for the version after the next one — paginated, idempotent, versioned, and instrumented.

How we approach it

Five principles that shape every Build engagement.

01

Wedge before platform.

We start by isolating the smallest piece of product that earns trust on its own — a workflow, a calculation, a single dashboard. Platform thinking comes after we've shipped something a customer would pay for unbundled.

02

Operational scaffolding from day one.

Tracing, structured logging, audit trails, eval-style assertions on critical paths. The instrumentation goes in before the second feature, because the version of the system that's hard to operate is the version that gets thrown away.

03

Internal tools as a first-class surface.

The customer admin, support console, and debugging UI ship alongside the product they serve. Your team's ability to operate the platform is non-negotiable, so it gets the same design attention as the customer-facing surface.

04

Migrations done quietly.

Parallel architecture, shadow-mode validation, customer-by-customer cutover, no marketing event around the swap. The customer's first signal that their system was replaced should be that it stopped breaking.

05

Built to inherit.

Documented at the architectural level, not just the line level. We stay long enough that your team genuinely owns the system — and we measure success by what survives our exit.

Tools we reach for
  • TypeScript
  • Next.js
  • Node.js
  • PostgreSQL
  • Redis
  • Kafka
  • Temporal
  • AWS
  • Terraform
  • Stripe
  • OpenTelemetry
How it starts

A discovery call, a fit conversation, and only then a quote.

A typical Build engagement starts with a 30-minute call where we map the system, the constraints, and the outcome you need. If it's a fit, we follow with a one- to two-week paid discovery — architectural review, real estimates, and a decision on whether the partnership is worth pursuing at all.

We'll tell you whether we're the right team before we tell you a price.

Ready when you are.

A 30-minute conversation. We'll listen. If we're a fit, we'll say so. If not, we'll point you to someone who is.

No discovery decks · No sales calls · One conversation