THE SHORT VERSION

Key takeaways

  • Define a stage by what the client can review, not just an internal task list.
  • Agree acceptance criteria and dependencies before publishing the plan.
  • Keep approval and payment confirmation as separate milestones.

A useful software stage ends with something a client can examine and accept. A list such as design, development and testing is only a starting point. Each stage also needs a defined result, a review method and a clear boundary around what comes next.

This guide is for a small studio setting up a project with a paying client. The examples describe a fictional internal request-management application. They illustrate planning choices rather than promise that a particular number of stages suits every software engagement.

Start with the decisions the client must make

Before entering stages into a CRM, identify the decisions that affect later work. The client may need to approve user roles before screen design, screen behaviour before implementation, and deployment responsibilities before handover. Those decisions explain why the stages exist and why their order matters.

Ask who can make each decision. A department contact might understand daily operations without having authority to approve the final deliverable. Name a review owner and arrange a backup contact outside the tool if needed. Sending work to an unavailable approver can stop an otherwise healthy project.

Separate internal tasks from client outcomes. Configuring a development environment is real work, but the client may have nothing meaningful to approve at that point. It can sit inside an implementation stage rather than become a standalone milestone whose completion is difficult to explain.

Describe the reviewable result

Write a sentence beginning with what the client will receive. For example, the requirements stage delivers an agreed role matrix, a list of supported request types and acceptance scenarios. The sentence should make sense without mentioning a developer's preferred framework or internal team structure.

Then describe how the result will be reviewed. A document can be reviewed through comments; an interactive feature needs a demonstration or accessible review environment. If the client needs sample accounts or synthetic records, prepare those before asking for approval.

Build a six-stage example around dependencies

For the fictional application, Stage 1 covers requirements and planning. Its output is a concise description of users, requests and approval boundaries. Questions about who can change a completed request belong here because their answers influence both interface design and permission rules.

Stage 2 covers interface design. Its output shows the request form, reviewer queue and status history. The client checks the important paths and error messages, rather than approving only colours. A visually attractive screen can still leave an essential business decision unresolved.

Stage 3 implements account access and administration. Its demonstration uses synthetic administrator and employee accounts. The client checks that each role sees the intended controls. This stage establishes the access model needed for the main workflow without assuming that every employee should have administrative privileges.

Stage 4 implements request submission and review. A demonstration follows a new request through correction and approval. It includes an incomplete submission and an unavailable attachment, so the review covers ordinary failures as well as the successful path.

Stage 5 covers agreed acceptance checks and corrections. Its output is a list of demonstrated scenarios, resolved issues and any explicitly accepted limitations. This is not an invitation to introduce unrelated features without discussing their effect on scope and timing.

Stage 6 covers deployment and handover. Its output includes operational instructions, assigned ownership and a record of what was delivered. Completion should leave the client able to find the application, understand access arrangements and know where to report an issue.

Make acceptance criteria observable

An acceptance criterion should describe behaviour somebody can observe. Replace a phrase such as easy to use with a concrete action: a reviewer can find requests waiting for their decision and open the associated evidence. That makes the discussion less dependent on personal interpretation.

Avoid criteria that combine several unrelated decisions. If one sentence requires a dashboard, an export and a notification, a failure in one area makes the whole sentence difficult to evaluate. Split the behaviours and say which ones are essential for this stage.

Include exclusions and assumptions

Document exclusions next to the scope. A request-management application might support internal requests without supporting purchases or payroll. Explicit boundaries help the client identify a missing requirement early, when it is easier to discuss than after the final demonstration.

Record assumptions with owners. If the client must supply approved terminology, name the person responsible and the date needed. An assumption is not a completed task. When it fails, discuss the resulting scheduling decision instead of quietly changing the stage's expected outcome.

Assign stage values without confusing progress

The project value and the stage plan describe different things. One represents the agreed commercial amount; the other describes the order of deliverables. A stage with a larger fee is not automatically more complete, more urgent or more important to the client's daily work.

With an advance, decide the upfront percentage before distributing the remaining balance. Keep the displayed arithmetic understandable to both parties. The remaining stage amounts should sum to that balance, and the stage labels should still describe delivery outcomes rather than accounting categories.

In Stageflow's approval-first workflow, verified advance payment makes the first stage ready for work. The administrator starts work and submits a delivery. Employer approval makes stage payment available, and confirmed payment completes that stage and unlocks the next one. Approval alone does not settle an unpaid stage.

Review the plan together before publishing

Read each stage aloud with the review owner. Ask what they would need to see to approve it and what would make them request a revision. If their answer introduces a new deliverable, update the draft plan before treating the original wording as agreed.

Look for circular dependencies. A design stage cannot depend on final production data if the data-import process is scheduled much later. Use a representative synthetic dataset for design review, and make the later data-related work explicit in its own stage.

Also review practical access. A client who cannot enter the review environment cannot meaningfully approve a feature. Arrange the account and demonstrate the relevant path without sharing administrator credentials. Keep preparation instructions next to the delivery so the review does not depend on a separate conversation.

Publishing should follow this review, not replace it. Stageflow locks a published plan, so resolve unclear scope and pricing while it is still a draft. Changes discovered later need a deliberate discussion and an appropriate supported process rather than an informal rewrite of history.

Frequently asked questions

Does every software project need six stages?

No. Six stages are a useful illustration, not a universal rule. A small modification may need fewer review points, while a complex implementation may need more. Keep a stage only when it produces an understandable outcome or resolves a dependency that matters to subsequent work.

Can development work happen in parallel?

Teams can plan internal work separately, but the client-facing sequence should remain clear. Stageflow exposes sequential stage progression. Do not describe parallel internal activity as an approved or payable later stage when the required previous milestone has not been completed.

What if the client changes a requirement?

First decide whether the request corrects the agreed behaviour or adds new scope. Document the distinction and discuss its effect before promising a date. A revision request should identify the specific delivery being reviewed, so the original expectation and subsequent decision remain understandable.

Conclusion

Start with one reviewable outcome for each stage, then add acceptance criteria, dependencies and a responsible reviewer. Walk through the whole plan with the client before publishing it. A clear sequence gives both parties a practical basis for delivery, review and payment decisions.

Explore the project and implementation options

The Stageflow project page explains the available workspace and its access requirements. Use it to compare the process described here with the current application. The automation service page is a starting point for discussing additional workflow requirements; this article does not imply those customizations are already implemented.

Prepared with AI assistance and checked against the project source. Examples are fictional process illustrations, not customer results. GeM Flow is an independent internal workspace, not an official GeM service.

Discuss a focused implementation

Explore the service scope and share the process you want to improve.

Explore this service