Skip to main content
Process

How we deliver: no surprises, no black boxes.

A structured, transparent delivery method. You see progress every two weeks, decisions are written down, and the next step is always clear.

The delivery path

  1. Discovery call

    30 minutes

    Understand the problem and check we're a good fit. No slides required.

  2. Discovery sprint

    ~2 weeks

    Process analysis, technical specification, data assessment, roadmap, and estimate.

  3. Build in sprints

    2-week cycles

    Working software demoed every sprint, with a shared backlog you can see.

  4. Test & train

    Automated tests, user acceptance testing, and role-based training.

  5. Launch

    Phased go-live with a runbook and rollback plan.

  6. Hypercare & support

    30 days+

    Fast fixes after launch, then an optional support plan.

What you can expect from us

Visible progress

Demos every sprint and a backlog you can read.

Written decisions

Architecture and scope decisions recorded with reasons.

Direct access

Talk to the engineers doing the work, not just an account manager.

Early bad news

If something is slipping, you hear it first and with options.

Why we work this way

Software projects usually go wrong in predictable ways: unclear scope, late surprises, and decisions nobody remembers making. Our process is designed around preventing those. A short paid discovery turns assumptions into a written plan, two-week sprints keep progress visible, and every important decision is recorded with its reasons.

As a small team, we also keep the process light. There are no layers of status reports or steering committees; you see working software, talk to the engineers building it, and decide together what comes next.

What you get at each stage

StageYou receive
Discovery callAn honest view of whether we're the right fit
Discovery sprintProcess maps, specification, data assessment, roadmap, and estimate
Each sprintA demo of working software and an updated backlog
TestingAutomated tests, user acceptance sessions, and training materials
LaunchA runbook, rollback plan, and supported go-live
HypercareFast fixes and daily check-ins while the team settles in

How we communicate

You get a shared channel with the engineers, a short written update each week, and a demo at the end of every sprint. If something is slipping or a risk appears, you hear about it early, with options rather than excuses. Decisions that change scope, cost, or timing are written down and agreed before work continues.

What we ask from you

  • A decision-maker available every week
  • Access to the people who do the work
  • Timely feedback on demos
  • Test data and system access when needed

Scaling the process to the project

Not every engagement needs the full path. A single integration or a performance review may need only a short scoping call and a few weeks of focused work. A full ERP rollout uses every stage. We agree the right level of process during the first conversation, so small jobs stay small and large ones get the structure they need.

Typical engagement shapes

EngagementUsual path
Small fix or integrationScoping call, fixed quote, delivery, short handover
New module or featureShort discovery, one or two sprints, testing, release
ERP rollout or migrationFull discovery, phased sprints, rehearsals, launch, hypercare
New product (SaaS, app)Discovery, prototype, iterative build, beta, launch
Ongoing improvementsMonthly support plan with a shared priority list

After the project

When a project ends, you receive everything needed to run and change the system: code, infrastructure definitions, documentation, and access to every account. Many clients then keep a small monthly plan with us for fixes and improvements; others take it in-house. Either is fine, and the handover is designed so both work.

What a sprint demo looks like

Every two weeks we show working software on realistic data, not slides. The people who will use the system attend, try it, and tell us what's wrong while it's still cheap to change. We record the decisions made in the demo and update the plan the same day.

If a sprint went badly, the demo is where you hear about it, along with what we're changing. Surprises are cheapest when they're small, so we'd rather share a small problem early than a large one late.

How changes to scope are handled

Scope changes are normal; unmanaged ones are not. When a new request arrives, we estimate it, show what it would displace or cost, and let the project owner decide. Nothing slips in quietly, and nothing is refused without a reason.

Small changes are often absorbed in the next sprint. Larger ones become a short written change note with an estimate. Either way, the backlog stays the single source of truth for what's being built.

Signs a project is healthy

  • Demos happen every two weeks, on real data
  • Decisions are written down and easy to find
  • The backlog is current and prioritized by the owner
  • Risks have owners and dates, not just labels
  • Users have touched the system well before go-live

Handover is planned from day one

The goal of every project is a system your team can run without us. So documentation is written as we build, not in a rush at the end; your developers are invited to code reviews; and the final weeks include walkthroughs of deployment, monitoring, and the parts of the system most likely to need change.

If you'd like us to stay on afterwards, support plans have written scope and response times. If you don't, you should be able to carry on without missing a beat.

Written updates, every week

Each week you get a short note: what shipped, what's next, and any decisions or risks that need your input. No surprises at the end of a sprint.

Frequently asked questions

How involved do we need to be?
A project owner with a few hours a week, plus key users for workshops, demos, and testing. Involvement is the strongest predictor of a good outcome.
Can the process be lighter for small projects?
Yes. Small projects keep the same principles, such as demos and written decisions, with less ceremony around them.