Software projects usually go wrong because two people pictured different things. A short written scope of work, agreed before anything is built, is the cheapest way to make sure everyone has the same picture.
It doesn’t need to be long. A good scope fits on a few pages, and each section answers a question someone will otherwise ask halfway through the project, when changing course costs far more.
What a scope of work is, and what it isn’t
A scope of work says what will be built, for whom, by when and for how much, and how you’ll both know it’s finished. It’s written in plain words that the people paying for the project and the people using it can follow.
It isn’t a technical specification. Database designs, screen layouts and code structure come later, once the scope is agreed. It also isn’t the contract, though a contract usually points to it as the description of the work.
The problem, in plain words
Describe what isn’t working today and who it affects. “Staff spend Monday mornings copying figures between three spreadsheets” is more useful than “build a reporting platform”. A clear problem lets you judge every later decision against it.
Who will use it
List the groups of people who’ll use the system and what each needs to do. Staff, managers, customers and administrators usually need different things, and often different permissions. If one group matters most, say so.
What’s included, and what isn’t
The “not included” list matters as much as the “included” one. If integrating with your finance system, migrating old data or building a mobile app isn’t part of this project, say so. It prevents arguments and gives you a ready list for the next phase.
Assumptions and dependencies
Write down what the plan relies on: access to an existing system, someone available to answer questions each week, data supplied by a certain date. If an assumption turns out to be wrong, the scope says what happens next rather than leaving it to a dispute.
How you’ll know it’s done
Write acceptance criteria you can check: “A manager can approve a request from their phone” rather than “the approval process works well”. These become the tests at the end of the project, so both sides agree in advance what “finished” means.
Milestones you can see
Break the work into stages that each end with something you can try, not just a progress report. Seeing working software early is the best way to catch misunderstandings while they’re still cheap to fix.
How changes are handled
Something will change; it always does. Agree how a change is raised, who weighs up its cost and effect on the timeline, and who approves it. A simple rule, such as “changes are written down and priced before they’re started”, keeps the project honest.
Risks, named early
Every project has unknowns: an old system nobody has documentation for, a supplier whose cooperation you need, data that may not be as clean as hoped. Name them up front, with what you’ll do if they happen.
The cost of building it and of running it
The build price is only part of the cost. Include hosting, licences, support and updates for the first year, so the budget holder sees the full picture before deciding.
Who owns what at the end
Agree that the code, the cloud accounts and the documentation belong to you. If you ever change supplier, you should be able to hand everything over without asking permission.
Support after launch
Say what happens after go-live: who fixes problems, how quickly, and what’s covered. Even a simple line such as “fixes for the first three months are included” avoids awkward conversations later.
A sample outline
You can start from these headings and fill in a line or two under each:
- The problem and who it affects
- Who will use it, and what each group needs
- What’s included
- What isn’t included
- Assumptions and dependencies
- Acceptance criteria
- Milestones and dates
- How changes are handled
- Risks and what you’ll do about them
- Cost to build, and to run for the first year
- Who owns the code, accounts and documents
- Support after launch
A worked example
Say a 60 person organisation books annual leave on a shared spreadsheet. Managers miss requests, two people in the same small team sometimes end up off together, and HR spends a day each month checking balances by hand.
A scope for a simple leave booking system might read like this:
- Problem: leave is booked on a spreadsheet, so requests are missed, clashes aren’t spotted and balances are checked by hand.
- Users: staff book leave and see their balance; managers approve or decline for their team; HR sets allowances and runs the yearly report.
- Included: requests and approvals, balances, a team calendar that shows clashes, email notifications, the yearly report.
- Not included: payroll integration, sickness absence, a mobile app. These are listed for a possible second phase.
- Assumptions: HR supplies each person’s allowance and manager by a set date; staff sign in with their existing work accounts.
- Acceptance criteria: a manager can approve a request in two clicks from the email; the calendar shows when two people in the same team overlap; balances match HR’s figures for ten sample staff.
- Milestones: booking and approvals to try at week three, the calendar and report at week six, go-live at week eight.
- Changes: written down and priced before they’re started.
- Ownership and support: the code and accounts belong to the organisation; fixes for the first three months are included.
That’s a page and a half, and it answers almost every question that would otherwise come up in week five.
A scope of work checklist
Before you sign off a scope, check that it:
- describes the problem, not just the solution
- names every group of users
- says clearly what isn’t included
- lists the assumptions it depends on
- has acceptance criteria you could test
- breaks the work into stages you can try
- says how changes are handled
- shows the running costs, not just the build price
- states who owns the code and accounts
- says what support covers after launch
If you’re planning a project and want help writing the scope, send us an enquiry. We write one for every software development project before any work begins.




