Method

Phased delivery with formal acceptance: how a project actually runs

A software project is not judged on its opening schedule but on what happens in month four, when a forgotten rule surfaces and the switchover date is closing in. Batch delivery and formal acceptance exist to make that moment manageable rather than adversarial.

Two weeks

per sprint, each closing with a demo of the running software

Signed report

at every milestone: acceptance is a contractual act, not an impression

Gradual switchover

the old system keeps running until the new one has proved itself

Phased delivery with formal acceptance is the only mechanism we know of that lets a client know, at any moment, what is finished and what is not. It replaces the impossible question — "how is the project going?" — with a verifiable one: which batches have been accepted, and which test cases are still open on the current one?

The rhythm: two-week sprints, contractual milestones

Two timescales coexist, and confusing them is the first source of misunderstanding. The sprint is an internal working rhythm: two weeks, a demo at the end, no contractual commitment attached. The milestone is a contractual event: one complete functional batch, an acceptance run, a signed report, and a portion of the scope definitively closed. A milestone usually spans two to four sprints.

End-of-sprint demoMilestone with formal acceptance
FrequencyEvery two weeksEvery four to eight weeks
PurposeShow the running software, correct the trajectoryGet a complete functional scope signed off
Who attendsThe business owner and, where useful, the affected usersThe business owner, the user testers, the signatory
What it producesMinutes and a list of adjustmentsA signed acceptance report, with any reservations listed
Contractual effectNoneThe batch is deemed compliant; it triggers the associated payment
If there is disagreementAdjusted in the next sprintReservations recorded, fixed, then re-tested on the open points only
Separating the demo from the milestone avoids both traps: signing off in a meeting what nobody tested, and waiting six months before showing anything.

What formal acceptance actually means

"Acceptance" does not mean the client watches a screen and says it looks fine. It is a written procedure, prepared before the batch is built, and executed by the people who will actually use the tool.

  1. An acceptance script is written when the batch is scoped: the list of cases to test, expressed in business language, each with its expected result.
  2. A dedicated acceptance environment is provided, loaded with your own anonymised production data — not a demo data set.
  3. Your users run the cases one by one and record, for each: compliant, non-compliant, or compliant with a comment.
  4. Non-compliances are classified together as blocking or minor. Blocking items are fixed before signature; minor ones become dated reservations.
  5. The report is signed by someone authorised to commit the organisation. It lists the cases passed, the reservations and their correction deadline.
  6. Signature triggers three things: the batch is deemed compliant, the milestone invoice is issued, and that part of the scope is closed to further debate.

The client's role: an available, empowered business owner

No batching scheme works without someone on the client side able to answer and to decide. It is the condition most often underestimated at signature, and the first cause of drift when it is not met. The business owner does not need to be technical; they need to be legitimate.

  • Available: roughly half a day a week in steady state, more during acceptance phases.
  • Empowered to arbitrate: able to push a request to the next batch, or rule that an edge case will not be handled, without convening a board.
  • Holder of the real rules: the person who knows why one supplier has had derogatory treatment since 2019, not only what the official procedure says.
  • Able to mobilise testers: acceptance is run by users, not by the business owner alone and not by us.
  • A single point of arbitration: four stakeholders producing three contradictory opinions cost more than any change order.

Where that condition cannot be met — a small permanent team, a management absorbed by operations — it is better said at scoping, and the batching adapted: smaller batches, spaced further apart, with shorter acceptance runs. A project sized for the client's real availability moves faster than an ambitious one waiting on answers.

Operations keep running during the build

A rebuild never lands on empty ground. While we build, the organisation keeps working: revenue declarations come in, approval agreements are renewed, the annual statement falls due on its date. The legacy system therefore has to stay operational until the new one has proved itself on the process concerned.

  1. Order the batches by pain, not by architecture

    The first batch tackles the process whose current cost is easiest to measure — often the rebate calculation or the declarations. A first batch that is technically necessary but invisible to users burns the project's credit.

  2. Run the new system alongside the old

    On financially sensitive processes, the first live campaign runs twice: in the legacy tool and in the new one. You only switch once the two results reconcile.

  3. Switch over by user population

    A pilot group of members or staff moves first, on a reduced scope. The rest follow once the usage frictions are fixed.

  4. Decommission the old system explicitly

    The shutdown date is decided and announced, not endured. As long as no date is set, both tools coexist indefinitely and double entry becomes permanent.

The criterion that governs the whole plan

At no point should the group have to say: we cannot close the year this time, we are changing systems.

That constraint outranks all the others, and it is checked batch by batch at scoping: if the current batch slipped by two months, which business deadline would be missed? When the answer is "an annual deadline that cannot be moved", the batch is re-cut or shifted outside the critical window. It is also what keeps the plan negotiable until the last moment: the order of batches serves the organisation's calendar, not the other way round.

MEKANO is a Lyon-based development studio. Working this way, we delivered the full rebuild of the management system of a Lyon buying group of more than 60 member companies — member and supplier portals, approval workflows, revenue declarations, a year-end rebate engine and document management — at a fixed price, in successive batches, in Go, React and PostgreSQL.

Frequently asked questions

What if we refuse to sign an acceptance report?
Nothing dramatic: it is anticipated. Non-compliances are classified together, blocking ones are fixed, and a second acceptance run covers only those points, not the whole batch. Refusal only becomes an issue when it concerns requests that were not in the batch scope: those are then handled as changes, priced and arbitrated, and the batch is signed with the reservations recorded in the report.
How much user time does acceptance take?
For a typical functional batch, expect two to four half-days spread over a week, involving two to four representative users. The acceptance script is supplied: they run cases described in business language rather than hunting for bugs at random. For a sensitive batch such as a calculation engine, acceptance takes longer because it includes replaying a past campaign and comparing the amounts line by line.
Can the content of later batches change mid-project?
Yes, as long as they have not started, and that is one of the points of batching. Watching the first batch run reveals priorities no workshop would have surfaced. Re-ordering happens at a milestone, with a fresh estimate if the overall content changes. What the method rules out is continuously altering the batch currently under development — reliably the fastest way to wreck a schedule.
How long between signature and the first batch in production?
On the management projects we run, the first batch is usually live between eight and twelve weeks after kick-off, scoping included. That timeline depends far less on the volume of development than on the time needed to write down the rules as actually applied and to obtain usable source data. Projects that slip almost always slip before the first line of code, not after.
What happens to the legacy system during the rebuild?
It stays in service, and we design the batching around that constraint: no business deadline may be missed because of the project. In practice that means a period of parallel running on financially sensitive processes, a switchover by user population, and an explicitly decided shutdown date. Endless double entry, because that date was never set, is the scenario we work hardest to avoid.

Let's talk about your situation

Thirty minutes, no commitment. You leave with a straight answer on feasibility, a budget order of magnitude and the next steps.

Book the call