Operating Model

Calm. Sequential. Built to hold up.

A short, deliberate sequence that compresses the distance between intent and a working system — without skipping the quiet work that makes the result hold up after launch.

The sequence

Six phases, one continuous motion.

Each phase has a defined output. The work moves forward only when the previous phase has produced something concrete — not a slide, a working artifact.

01

Discovery · 1–2 weeks

Frame the outcome

We start with the commercial goal, the customer journey, and the operational reality the system has to live inside. Discovery ends with a written build map — not a hopeful list, a real plan.

  • Goal & success criteria
  • User & operator journeys
  • Technical constraints
  • Build map & sequencing
02

Architecture · 1–2 weeks

Architect the system

Convert intent into pages, flows, data structures, automations, and surfaces. We design the system the way an engineer would diagram it — clear seams, named responsibilities, no magic.

  • Information architecture
  • Data model & schema
  • Surface inventory
  • Integration map
03

Execution · 4–10 weeks

Build the first real version

Iterative production work in weekly slices. By the end of week one you should be able to click through a real, deployed system. Every subsequent week adds capability against the priority order set in discovery.

  • Weekly deployable slices
  • Working software, end-to-end
  • Continuous client review
  • Quiet, daily craft
04

Refinement · 1–3 weeks

Refine against real use

Pressure-test the system against actual users, edge cases, and operational reality. This is where the experience moves from "complete" to "considered" — the polish that's expensive elsewhere is built in here.

  • UX & copy refinement
  • Performance & accessibility pass
  • Edge-case coverage
  • Operator readiness
05

Deployment · 1 week

Launch with intent

Production hardening, observability, documentation, and a deliberate cutover. We treat go-live as the start of the operational lifetime of the system, not the end of the project.

  • Production hardening
  • Observability & alerts
  • Operator documentation
  • Supervised cutover
06

Support · ongoing

Sustain and evolve

A stabilisation window is included with every project. From there, many clients move into a monthly retainer for continuous iteration; others take ownership in-house. The system is built to be owned either way.

  • Stabilisation window
  • Monthly retainer (optional)
  • Quarterly system review
  • Clean handover at any time

Operating Principles

A few rules we don't compromise on.

These aren't slogans. They're the constraints that make the rest of the work possible.

Principle 01

Outcome before output

Every artifact — a screen, a query, an endpoint, an automation — exists in service of a named outcome. If we can't say which one, we don't build it.

Principle 02

Working software, weekly

By the end of week one, the client can click through a real, deployed system. After that, every week adds capability, not promises.

Principle 03

Restraint in scope

We'd rather ship a smaller system that works perfectly than a broader one that almost works. Restraint is a feature, not a limitation.

Principle 04

Architecture is documentation

The shape of the system should explain itself. Names, seams, and structure are the first place a future engineer should look — and find what they expect.

Principle 05

Built to be owned

No proprietary lock-in, no opaque choices, no magic. Clients who want to take the system in-house can do so cleanly. The work belongs to them.

Principle 06

Quiet by default

No theatre, no Slack performance, no daily standups for their own sake. The work shows up in the deployed system every week, on schedule.

Begin

Want to walk through this with us?

Discovery is the cheapest, most useful part of any system. A first conversation usually takes 30 minutes.