03 Process 4 steps, one discipline

We don't sell uncertainty.
We sell action.

We approach every project with the same methodology: clear KPIs, deliverables you own and a transparent process you follow through weekly demos. No reports for the drawer, no black boxes.

Explore the 4 phases Talk about your project
~6 weeksaverage time to go-live
240+projects completed
%92success on the first try
2 weekssprint cadence
01 Discovery 5 business days
02 Design 1–2 weeks
03 Build 4–12 weeks
04 Scale ongoing
01 Overview 02 4 Phases 03 Cadence 04 Deliverables 05 Principles 06 Your side
01 · Overview

From 5 days to live, then beyond.

It starts with a week of discovery and ends with a week of go-live. In between, a design phase and a build phase. After that, scale and continuous improvement.

01 5 business days

Discovery

Data, processes, KPIs. We clear up the uncertainty in 5 days.

Scope document + success criteria
02 1–2 weeks

Design

Architecture, prototype, eval criteria. Everything we decide is measurable.

Architecture + clickable prototype
03 4–12 weeks

Build

2-week sprints. A live demo every sprint, adjustments after every demo.

Production-grade code + evals
04 ongoing

Scale

30 days of hyper-care, then a retainer or self-served.

Observability + continuous improvement
02 · 4 Phases

Every phase has its own discipline.

Moving from one phase to the next takes tangible outputs. Not "let's get started," but "we've made the call."

01 5 business days

Discovery phase

Uncertainty is our problem, not yours.

A 5-business-day intensive workshop. On day one we listen; on the last day we decide. In this phase both sides need to say "yes, we're sure this is the right project" — if we're not sure, neither of us should start.

Activities
  • 15+ stakeholder interviews (1:1)
  • Current process map
  • Data inventory & quality check
  • Risk & compliance assessment
  • Use case backlog (scored)
Deliverables
  • Scope document (10–15 pages)
  • Success criteria + KPIs
  • Draft architecture
  • Risk map
  • Cost & timeline estimate
Owners
  • Discovery Lead (ours)
  • Strategy / PM (ours)
  • Sponsor (yours)
  • Data owner (yours)
Decision point
  • Go / no-go decision
  • Output: signed scope
  • Alternative: pivot proposal
  • If needed: we say no and refund the fee
02 1–2 weeks

Design phase

Everything we decide is measurable.

System architecture, model selection, eval criteria, prototype. This is the phase where we make the "this is what we'll build" call. Not a single word is left open to interpretation — everything is documented, every decision justified.

Activities
  • System architecture (ADRs)
  • Model selection + eval suite
  • Data pipeline design
  • Clickable prototype in Figma
  • Authorization & security
Deliverables
  • Architecture document (ADRs)
  • Eval suite (measurement engine)
  • Clickable prototype
  • Sprint plan + Jira/Linear
  • API contracts
Owners
  • Solution Architect (ours)
  • UX Designer (ours)
  • Tech Lead (ours)
  • Architecture owner (yours)
Decision point
  • Architecture sign-off
  • Output: clickable prototype
  • Scope freeze
  • Sprint 1 kickoff
03 4–12 weeks

Build phase

Live through sprints, transparent through demos.

We build in 2-week sprints. A live demo at the end of every sprint, adjustments after every demo. No secret lab — every week you learn what we did, what we couldn't do and why anything slipped.

Activities
  • 2-week sprint cycle
  • Daily standup (Slack)
  • Weekly check-in (30 min)
  • Sprint demo (live, recorded)
  • Continuous evals + testing
Deliverables
  • Production-grade code
  • Eval suite (before/after)
  • Documentation + runbook
  • Deploy pipeline (CI/CD)
  • Monitoring + alerting
Owners
  • Engineering Team (ours)
  • Product Manager (ours)
  • QA / Eval Lead (ours)
  • Product Owner (yours)
Decision point
  • UAT (user acceptance)
  • Production-readiness checklist
  • Go-live decision
  • Soft launch vs. big bang
04 30 days + ongoing

Scale phase

Go-live is where the real work begins.

A 30-day hyper-care period after go-live: intensive monitoring, fast fixes, user feedback. After that: a retainer (ongoing development) or self-served (you run it yourself). The choice is yours, and the door is always open.

Activities
  • 30 days of hyper-care (24/7)
  • Real-time monitoring
  • User feedback & quick fixes
  • Cost & performance optimization
  • Monthly business review
Deliverables
  • Live dashboard
  • Monthly performance report
  • Training videos + documentation
  • New feature roadmap
  • Hand-off package (if needed)
Owners
  • Customer Success (ours)
  • Site Reliability Lead (ours)
  • Team specialist (yours)
  • Executive sponsor (yours)
Decision point
  • Choosing the engagement model
  • Retainer / self-served / hand-off
  • Kicking off a new use case
  • Joint annual planning
03 · Communication cadence

Regular demos, no surprises.

What we discuss on which day, and what we show on which day, is set in advance. "What are they actually doing?" never comes up.

Daily

Daily Slack Update

A channel update at 9:30 a.m. What got done yesterday, what's on for today, what we're waiting on. 5 lines, a 30-second read.

Owner: Engineering team
Weekly

Weekly Sync

A 30-minute check-in. Where the sprint stands, risks, anything waiting on your side. Recorded, so you can catch up later if you miss it.

Owner: Product Manager
Every 2 weeks

Sprint Demo

A live demo with screen sharing. 45 minutes. All stakeholders invited. Questions in the open, decisions on the table. Recorded.

Owner: Tech Lead
Monthly

Business Review

60 minutes a month. KPIs, ROI, user analysis, the roadmap ahead. This is where strategic decisions are made.

Owner: Account Lead
Quarterly

Quarterly Strategy

A strategic review with senior leadership. Annual goals & budget revision. A new use case backlog. With C-suite participation.

Owner: Partner / Director
Immediate

Incident Response

When something goes wrong in production, we're on it within 15 minutes. Slack alerts, PagerDuty integration. Post-mortem within 24 hours.

Owner: On-call Engineer
04 · Deliverables

What we deliver in every phase.

Not talk, not paper — working artifacts you own, open to your pushes, running in production.

01

After Discovery

  • Scope document (Notion / PDF)
  • Success criteria (KPI matrix)
  • Process map (Miro)
  • RACI responsibility matrix
  • Cost & timeline estimate
  • Risk map
02

After Design

  • Architecture document (ADRs)
  • Clickable Figma prototype
  • Eval suite (written + automated)
  • API contracts (OpenAPI)
  • Sprint plan (Linear / Jira)
  • Security & compliance checklist
03

During / After Build

  • Production code (in your repo)
  • Technical documentation
  • Operations runbook
  • CI/CD pipeline
  • Eval results + trends
  • Sprint demo recordings
04

During Scale

  • Live dashboard (Looker / Grafana)
  • Monthly performance report
  • Training videos + materials
  • Alert / incident playbook
  • 12-month roadmap
  • Hand-off package (on request)
05 · Principles

Six principles, non-negotiable.

These aren't up for negotiation. Working with us means working with them.

01

Fixed scope, fixed price

We don't do T&M (time & materials). The scope is in writing, the price is in writing. Counting hours wastes your time and ours.

02

Production-first

No "the pilot works, we'll move it to production later." Production-grade code from the first line, an eval suite from the first week.

03

Demo > spec

A working demo instead of a written spec. A live demo at the end of every sprint is a must. The one thing beyond debate: what you see with your own eyes.

04

Ownership transfer

The code is yours, the repo is yours, the accounts are yours. No SaaS dependency comes from us. You can walk away or carry on whenever you want.

05

Transparency

Pushes are visible on GitHub, conversations are open in Slack, sprints are live in Linear. No black box.

06

30 days of hyper-care

30 days of intensive support after go-live. Performance, bugs, user feedback — instant response, zero fees.

06 · Your side

What you can expect from us & what we expect from you.

Good partnerships start with clear expectations. Here are the non-negotiable responsibilities on both sides.

We deliver

  • Discovery leadership — workshops, interviews, documentation
  • Architecture & design decisions — justified and documented
  • Production-grade code — pushed to your repo
  • Sprint demos — live, every 2 weeks
  • Evals & monitoring — setup and dashboards
  • Documentation — code, runbooks, user guides
  • Training — hands-on transfer to your team
  • 30 days of hyper-care — intensive support after go-live

What we expect from you

  • Sponsor — an empowered decision-maker for the whole project
  • Data owner — data access + answers to our questions
  • Stakeholder access — participation in interviews
  • Demo attendance — 45 minutes every 2 weeks
  • Decision speed — feedback within 48 hours
  • Test data — an anonymized sample
  • Approver — a team member for UAT
  • Candor — tell us the real problem, don't look for heroes

We carry 80%, you carry 20%. But without that 20%, the 80% means nothing. A good project is rowed from both sides.

Contact

Let's start with a 5-day discovery workshop.

Sign on a Friday evening, start the workshop on a Monday morning. A clear scope by that Friday. We reply in under 24 hours.

We reply in under 24 hours.