Skip to content
QuantmHill

How we work

No surprises is a process, not a promise.

Four phases, three ways to engage, and a first week you can measure us against. This page is the operating manual for every QuantmHill engagement — read it now, hold us to it later.

The process

Four phases, in order, every time — not because process is sacred, but because each phase exists to kill a specific way software projects die. Every phase ends with artifacts you keep.

See what the process produces

Phase 01

Diagnose

We start by reading, not proposing. Senior engineers go through your codebase, your infrastructure, and your delivery history, then interview the people who live with the system every day. You get a written diagnosis you can act on — with us or without us.

What you get

  • Architecture review document
  • Risk register, ranked by cost of inaction
  • Costed roadmap with sequencing and dependencies
  • Team-shape recommendation

Phase 02

Plan

The diagnosis becomes a plan you could hand to any competent team. Milestones map to outcomes you can verify, not activity we can bill, and the riskiest technical decisions get design docs before a line of production code is written.

What you get

  • Statement of work with milestone acceptance criteria
  • Technical design docs for the high-risk decisions
  • Delivery plan in your tracker, not ours
  • A named engineering owner for every workstream

Phase 03

Build

Senior engineers ship in weekly increments, with tests and CI from the first commit. You see working software every week, and every decision that shaped it lands in a written record — so nothing important lives in one person’s head.

What you get

  • Working software, demoed every week
  • CI/CD pipeline and test suite from the first commit
  • Architecture decision records as they happen
  • Weekly written ship notes

Phase 04

Scale

When the system works, we make it survivable without us. We document, instrument, and hand over — or scale the team up if the roadmap demands it. Either way, you are never renting knowledge you can’t keep.

What you get

  • Runbooks and incident playbooks
  • Observability dashboards wired into your on-call
  • Recorded handover sessions
  • Hiring support for your in-house team

Engagement models

Three ways to plug us in

You won’t find prices here — cost depends on shape and duration, and we’d rather scope honestly than anchor low. What never changes: the senior bar, the four phases, and the written cadence.

Project

Who it fits
A defined build with a deadline — a replatform, a migration, a v1 that has to ship.
Cadence
Weekly demos and milestone acceptance against a scope agreed in writing before we start.
How it flexes
Scope changes go through a one-page change note with cost and schedule impact — not a renegotiation.

Retainer

Who it fits
Teams that need reserved senior capacity every month without the overhead of hiring for it.
Cadence
Monthly planning against your roadmap, weekly ship notes, and a standing channel with the team.
How it flexes
Capacity scales up or down with a month’s notice, and the team stays the same people — no re-onboarding tax.

Dedicated team

Who it fits
A multi-quarter roadmap that needs a standing team embedded in your org, on your rituals.
Cadence
Your standups, your tracker, your release train — plus a quarterly review with our leadership.
How it flexes
Specialisms swap as the roadmap changes while the core of the team stays stable, so context compounds instead of resetting.

Not sure which shape fits? Most engagements start as a project and earn their way into a retainer. Ask us which fits

Tooling

The stack we bring

When you already have a stack, we work in it. When the choice is ours, this is what we reach for — boring where boring wins, current where it pays for itself.

Build

  • TypeScript
  • React
  • Next.js
  • Node.js
  • Python
  • PostgreSQL
  • Playwright
  • Storybook

Infra

  • AWS
  • GCP
  • Terraform
  • Kubernetes
  • Docker
  • GitHub Actions
  • Datadog
  • Sentry

Comms

  • Slack
  • Linear
  • Notion
  • Loom
  • Figma
  • Google Meet

Week one

What working with us feels like

The first five days set the pattern for everything after. Here’s how they run — and yes, day five means a demo of working software, not a deck.

  1. Day 1

    Kickoff

    You meet the whole team — everyone who will write code is on the call, no bait-and-switch. We agree the comms cadence, sort access, and leave you a written plan for the week.

  2. Day 2

    Access and archaeology

    Repos, infrastructure, and docs get read before anyone asks you a question that’s already answered. Open questions land in a shared doc you can respond to async.

  3. Day 3

    The plan, in your tracker

    A draft milestone plan and risk list appear in your tracker, not in a slide deck. You comment, we revise the same day.

  4. Day 4

    First merge

    CI is green, environments are reproducible, and a first real pull request is merged — a bug fix or a missing metric, something that matters.

  5. Day 5

    First demo

    A half-hour walkthrough of what shipped and the plan for week two, recorded so anyone who missed it can catch up async.

Want this process on your problem?

Book a strategy call. We’ll reply within one business day with an honest read — including whether we’re the wrong fit.