Discovery. Design. Build. Ship. Support.
Every engagement runs through five phases — visible, scoped, and gated. You always know what you’re getting next, who’s on it, and what we’ve agreed it’s worth. No offshore handoffs, no rotating bench, no surprise overruns.
How an engagement actually unfolds.
Each phase has a defined purpose, a defined deliverable, and a clear go / no-go gate. You can stop the engagement at any phase boundary — we’d rather you do that than commit to work that isn’t the right fit.
Discovery
1–3 weeks. We sit with the people who actually live inside the problem — IT, e-commerce, ops, marketing — and produce a written plan you could take to a different studio if you wanted to.
Design
2–5 weeks. UX, architecture, and integration design in parallel. Real screens, not lorem-ipsum mockups. Real diagrams of the data flow, not boxes-and-arrows handwave.
Build
4–20 weeks depending on scope. Fixed-bid phases with weekly demos. We ship working software end-to-end every sprint — no “you’ll see it in three months.”
Ship
1–3 weeks. Phased rollout with feature flags, blue/green where it pays off, runbooks the team can actually use, and the kind of go-live we’ve done a hundred times so it’s a non-event.
Support
Ongoing, optional. From a monthly health check + small enhancements through a named team on call. We don’t ghost projects after go-live — most clients have been with us for years.
What you get at each phase.
01 — Discovery
Goal: shared, written agreement on what the project actually is, what success looks like, and what it’s realistically going to take.
- Stakeholder interviews (IT, commerce, ops, marketing, finance where relevant)
- System inventory: ERP, OMS, PIM, CRM, identity, payments, tax, fraud, fulfillment
- Customer-master and item-master data quality assessment
- Risk register: what could derail this and how we’d know early
- Deliverable: Discovery document with phasing, dollar bands, and a real plan you could take elsewhere
02 — Design
Goal: resolve the hard decisions on paper before they become expensive in code.
- UX flows for the highest-friction screens (checkout, quote-to-order, dealer login, sales-rep impersonation)
- System architecture: storefront ↔ ERP, identity, eventing, PIM/CMS surfaces
- Integration design: idempotent endpoints, retry semantics, dead-letter queues, event schemas
- Non-functional targets: performance budgets, accessibility level, security posture
- Deliverable: Design package with screens, diagrams, schemas, and the build plan that follows from them
03 — Build
Goal: ship working software end-to-end every sprint, not at the end.
- Two-week sprints with weekly demos — not slide decks, the actual running app
- Fixed-bid phases when scope is clear; T&M with weekly burn-down for evolving scopes
- Senior pairing on hard problems; QA writing tests alongside the feature, not after
- Production-shaped environments from day one (staging mirrors prod, including the ERP bridge)
- Code reviews on every PR; no “contractor branch” that lands as a single commit
- Deliverable: Working software in your repo, with documentation your team can actually run from
04 — Ship
Goal: a go-live that’s a non-event because the risky parts already shipped behind feature flags.
- Pre-launch checklist: backups verified, rollback rehearsed, on-call rotation set
- Phased rollout: internal users → pilot customers → cohort → full traffic
- Synthetic monitoring + RUM in place before users arrive
- Runbooks written for the failure modes we know about, with named owners
- Deliverable: Live system with measurable health, an incident playbook, and a closeout retrospective
05 — Support
Goal: the work keeps working — and quietly improves — long after we’ve moved off the daily.
- Health-check retainer: monthly review of metrics, security posture, dependency drift
- Enhancement retainer: a regular cadence of small features your team can request directly
- Named-team retainer: an embedded engineer or two for higher-touch operations
- Optional quarterly architecture review as the platform and your business evolve
- Deliverable: Continuity. The same senior people you launched with are the people who answer the phone in month 18.
How we charge for it.
We’ll tell you on the kickoff call which model fits your engagement — and why. Discovery is always paid; we don’t do free pitches that turn into design-by-RFP.
Fixed-bid by phase
Best when scope is clear and the value is in predictability. Each phase has its own price, its own acceptance criteria, and its own go / no-go gate.
Time & materials, capped
Best for evolving or exploratory work. Hourly with a weekly soft cap so the budget conversation happens before the surprise.
Dedicated team / staff aug
For long-running platforms where our engineers sit alongside yours. Same senior bar, integrated into your stand-ups and your sprint cadence.
Retainer
Post-launch support across three tiers — health-check, enhancement, named-team. Monthly soft cap, named owner, no rotating bench.
The hard stuff is in the contract, not the kickoff deck.
Most agency-side surprises come from soft commitments that nobody wrote down. We work the other way: explicit acceptance per phase, weekly written status, and a small set of standing rules we don’t bend.
Phase gates are real
You don’t pre-pay for build before design is signed off. We don’t start a phase before the previous phase’s acceptance is documented.
Weekly written status
Every Friday: what shipped this week, what didn’t and why, what’s next, what’s at risk. Honest version. We’d rather flag a slip early than hide one.
Production-shaped staging
Staging mirrors production — same shape of data, same ERP bridge, same security posture. Bugs that only show up in prod are a category we work very hard to eliminate.
No silent timeline drift
If the scope grows, we tell you in writing the same week. The choice to absorb it, defer it, or pay for it is yours — not a surprise on the invoice.
Honest go / no-go
If discovery finds the project shouldn’t go forward, we’ll tell you. We’ve walked clients away from work that wasn’t a fit; better for everyone than a project nobody enjoys.
Named senior leads
The people who scoped the engagement are the people who ship it. Your engineering lead, your design lead, your QA lead are introduced by name in week one and don’t rotate off.
What you’ll have within the first week.
Setup & access
- Shared workspace (Teams or Slack) with a named channel for the engagement
- Source repo provisioned in your org or ours, your choice; CI configured
- SSO + access requests itemized so security has time to approve cleanly
- A status-doc URL that updates every Friday in the same place every week
Documents
- SOW with phase pricing and acceptance criteria
- NDA and DPA signed where data sharing requires it
- Discovery agenda with the questions we’ll work through
- Risk register seeded with the things we already know are likely to bite
People
- Named engineering lead, design lead, and QA lead introduced
- Account contact (Calvin or another senior) on every status
- Your stakeholder mapping — who’s decision-maker, who’s informed, who needs to sign
- Cadence: 30-minute weekly check-in + 30-minute monthly steering review
Discovery starts here.
Tell us where you are and what you’re trying to ship. We’ll come back with the right phasing, the right team, and an honest read on whether we’re the right hands for it.
877.609.9029