GainHQ
Go back

Software Development Scope of Work: How to Write One (With Template)

Statement of work document with in-scope and out-of-scope items and an agreed stamp

by GainHQ Editorial Team | Oct 26, 2026 | Software Development Insights | Editorial policy


Table of Contents
  1. What is a software development scope of work?
  2. How the scope of work fits with your RFP, PRD and proposal
  3. What to include in a software scope of work (template)
  4. How to scope a software project in 7 steps
  5. In-scope vs out-of-scope: an example
  6. Writing scope for agile projects
  7. Acceptance and change control
  8. Common scope of work mistakes
  9. How GainHQ can help

A software development scope of work is the part of a contract that states exactly what a vendor will build and deliver, what is excluded, how finished work will be accepted, and how changes will be handled. It turns a project idea into boundaries both sides can sign. A good one is short enough to read in one sitting and specific enough that two people reading it would draw the same line between "in scope" and "change request".

Below: what to include, how it differs from your RFP and PRD, a fill-in template, a worked example, and the change-control and acceptance clauses most templates omit.

What is a software development scope of work?

A software development scope of work describes the work a development team will perform and the results it will hand over. It usually covers objectives, deliverables, functional and non-functional requirements, timeline, assumptions, exclusions, acceptance and change control. It answers "what are we buying?", not "how will the code be written?".

That second point matters. US federal procurement rules, which are among the most detailed public guidance on writing work statements, tell agencies to "describe the work in terms of the required results rather than either 'how' the work is to be accomplished" and to "enable assessment of work performance against measurable performance standards" (FAR 37.602). They also tell buyers to state requirements in terms of "functions to be performed", "performance required" or "essential physical characteristics" (FAR 11.002). You do not need to follow federal rules, but the principle works for any software buyer: define outcomes and how you will measure them, and leave engineering choices to the team you hire.

Scope of work vs statement of work (SOW)

The two terms are often used interchangeably, and both are shortened to "SOW". In practice, the scope of work is the description of the work itself, while a statement of work is often the wider contract document that contains the scope plus commercial terms such as payment schedule, roles and governance. Many agencies sign a master services agreement (MSA) once and then a separate SOW for each project. Always check which meaning the other party intends before you start redlining.

Public-sector buyers also use two related documents:

Document What it states Who writes it Best fit
Statement of work (SOW) The tasks and deliverables required Buyer, often with vendor input Well-understood work with stable requirements
Performance work statement (PWS) Required results and measurable performance standards, not methods Buyer, or bidders from a SOO (FAR 37.602) Outcome-based contracts
Statement of objectives (SOO) Purpose, scope, period and place of performance, background, performance objectives and constraints Buyer; bidders then propose a PWS (FAR 37.602) Projects where the buyer wants vendors to propose the approach

The US government's TechFAR Hub argues that performance-based techniques "are a great fit for agile software development" because they let the contractor "be the experts" on technical delivery (TechFAR Hub).

How the scope of work fits with your RFP, PRD and proposal

The scope of work is not your first document. It usually comes after you have described the need and chosen a vendor, and it borrows from everything written before it.

Document Purpose Usually written by When
Software development RFP Asks vendors to bid on a described need Buyer Before vendor selection
Software development proposal Vendor's response: approach, team, estimate Vendor During vendor selection
Product requirements document (PRD) What the product must do, for whom, and why Product owner Before and during build; keeps evolving
Scope of work Contractual boundaries: deliverables, exclusions, acceptance, change control Buyer and vendor together At contract signature

If you are a startup at the idea stage, start with your MVP requirements and turn them into a scope of work once you have chosen a team. The scope should reference the PRD or backlog rather than copy it, so the requirements can evolve without rewriting the contract.

What to include in a software scope of work (template)

A complete software scope of work needs about a dozen sections. Use the table below as a fill-in template: copy the left column as your headings and answer the prompts in the middle column.

Section What to write Watch out for
1. Background and objectives The business problem, who the users are, and two to four measurable outcomes Objectives with no way to check them ("improve efficiency")
2. Deliverables Every item you will receive: working software per environment, source code, documentation, designs, test reports Forgetting non-code deliverables such as admin guides or design files
3. Functional scope Features and user journeys in scope, referencing the PRD or backlog by version Copying the whole backlog into the contract
4. Non-functional requirements Performance, security, accessibility, supported browsers and devices, data retention Leaving these implicit; they drive cost and testing
5. Out of scope An explicit list of what is not included Assuming silence means exclusion
6. Assumptions Facts the estimate depends on (volumes, existing APIs, content supplied by client) Assumptions that are really risks with no owner
7. Client responsibilities Access, test data, timely decisions, a named product owner, third-party accounts Delays caused by missing client inputs with no consequence agreed
8. Milestones and timeline Phases, milestone dates, and what "done" means for each Dates with no dependency on client inputs
9. Acceptance How and when each deliverable is reviewed, accepted or rejected Open-ended review periods
10. Change control How changes are requested, estimated, approved and recorded No process at all
11. Ownership and handover Who owns code, designs and data; repositories, credentials and documentation at handover Code held in vendor-only accounts
12. Governance Roles, meeting cadence, reporting and escalation path No named decision-maker on either side

Commercial terms (pricing model, invoicing, warranties, liability) usually sit in the wider SOW or MSA. Whether your scope can be fixed or must stay flexible depends on the pricing model you choose, and the milestones in section 8 should match a realistic software development timeline.

If you need a formal requirements specification behind section 3 or 4, the international standard ISO/IEC/IEEE 29148:2018 specifies the requirements engineering processes for systems and software and the information items they should produce (ISO). Note that ISO lists it as under revision.

How to scope a software project in 7 steps

Scoping a software project means turning a goal into an agreed set of boundaries before work starts. These seven steps work whether you are the buyer or the vendor.

  1. Write the outcome first. State the problem and the measurable result, for example "staff can book a technician in under two minutes", before listing any features.
  2. List users and journeys. Name each user type and the key journeys they must complete. This gives functional scope a shape.
  3. Set non-functional limits. Agree performance, security, accessibility and platform targets early, because they change architecture and testing effort.
  4. Draw the out-of-scope line. Write down what you are deliberately not building in this phase, including integrations, platforms and data migration.
  5. Record assumptions and dependencies. Note what must be true for the plan to hold and what the client must provide, with dates.
  6. Agree acceptance and change control. Decide how work will be accepted and how new requests will be handled before the first sprint, not after the first dispute.
  7. Review it together and sign. Walk through the scope line by line with the delivery team and the decision-maker. Ambiguities found now are cheap; the same ones found in testing are not.

These steps sit at the start of the software development life cycle, between planning and design.

In-scope vs out-of-scope: an example

The fastest way to prevent scope disputes is a side-by-side table. The example below is illustrative only. It is a hypothetical project, not GainHQ client work or data.

Illustrative project: a web-based booking portal for a regional appliance-repair company, phase 1.

Area In scope (phase 1) Out of scope (phase 1)
Users Customers and office staff Technicians' mobile app
Booking Customer selects service type, date and time slot; staff confirm or reschedule Automatic route optimisation
Payments None; payment taken on site as today Online card payments
Notifications Email confirmation and reminder SMS and push notifications
Integrations Export of daily bookings to CSV Two-way sync with the accounting system
Platforms Latest two versions of major desktop and mobile browsers Native iOS and Android apps
Content Vendor builds templates; client supplies all service descriptions and images Copywriting and photography
Data New database; client enters current customers manually Migration of historical job records
Languages English Additional languages

Every "out of scope" line is something a stakeholder might reasonably assume was included. That is the test for a useful exclusion list.

Writing scope for agile projects

An agile project can still have a firm scope of work. What you fix is the outcome, the constraints, the team and the way decisions are made, while detailed features live in a backlog that the product owner reprioritises each sprint. The Agile Manifesto values "customer collaboration over contract negotiation" and "responding to change over following a plan", but neither means working without a contract.

Sample agile contract language on the TechFAR Hub shows how this works in practice: the development process is "guided by the Product Owner's high-level requirements as expressed in the Product Vision", and "[r]equirements are defined at the beginning of each sprint (iteration)" (TechFAR Hub). In a private-sector scope, that translates into:

  • Objectives and non-functional requirements written firmly in the scope.
  • Functional scope expressed as the product vision plus the backlog version at signature.
  • A clause saying the product owner may reorder or replace backlog items within the agreed capacity without a formal change request.
  • A change request only when objectives, constraints, capacity or dates change.

Acceptance and change control

Acceptance and change control are the two sections that decide whether a scope of work prevents disputes or simply records them. Both need dates, owners and a clear outcome.

Acceptance

For each milestone, state who reviews the deliverable, how long they have, what counts as a defect that blocks acceptance, and what happens if nobody responds. Tie functional acceptance to written criteria for each user story; our acceptance criteria examples show checklist and Given/When/Then formats you can reuse.

Change control

A simple change-request flow is enough for most projects:

Step What happens Output
1. Request Either side describes the change and the reason Change request with an ID
2. Impact Vendor assesses effect on effort, timeline, cost and risk Written impact estimate
3. Decision Named decision-maker approves, rejects or defers Signed or recorded decision
4. Update Scope, backlog and timeline are updated New scope or backlog version
5. Log Change is added to a running change log Audit trail for both sides

Uncontrolled change is expensive even in very large, well-funded projects. In its 1995 fact sheet on Denver International Airport, the US General Accounting Office reported that change orders were among the factors that contributed to four delays in opening the airport, and that the automated baggage system's cost rose "from about $195 million to over $290 million" (GAO/RCED-95-241FS).

Common scope of work mistakes

Most scope problems come from what the document leaves unsaid rather than from what it gets wrong.

  • Describing activities, not results. "Develop the booking module" is an activity; "customers can book an available slot and receive an email confirmation" is a result you can test.
  • No out-of-scope list. Silence invites assumptions on both sides.
  • Hidden client dependencies. If the project needs your API keys, content or test users, say when.
  • Undefined acceptance. Without a review window and a defect threshold, "done" is a negotiation.
  • Copying the backlog into the contract. It makes every reprioritisation a contract change.
  • Ignoring ownership. Agree where code, designs and credentials live before development starts, not at handover.

How GainHQ can help

GainHQ has spent more than 15 years building software and has shipped more than 13 products, including our own Payrun (HR and payroll) and Gain.io (CRM and helpdesk) platforms. Our team of 30+ can help you turn an idea or RFP into a clear, buildable scope of work, then design and deliver it. See our services, including custom software development, MVP development, UI/UX design and technology consulting.

Frequently asked questions

What is a scope of work in software development?

It is the part of a software contract that defines what will be built and delivered, what is excluded, how work will be accepted and how changes are handled. It describes results and deliverables, not the coding approach.

What is the difference between a scope of work and a statement of work?

The scope of work describes the work and deliverables. A statement of work is often the wider document that contains the scope plus commercial and governance terms. Both are abbreviated "SOW", so confirm which one the other party means.

What does SOW mean in software?

In software, SOW usually means statement of work: the project-level contract document, often signed under a master services agreement, that sets out deliverables, timeline, acceptance, change control and payment terms for one engagement.

Who writes the scope of work, the client or the vendor?

Either can draft it, but both should shape it. The client owns objectives, constraints and acceptance; the vendor contributes deliverables, assumptions and estimates. Sign it only after both sides have reviewed it line by line.

How detailed should a software scope of work be?

Detailed enough that both parties would classify any new request the same way: in scope or change request. Fix objectives, deliverables, exclusions, acceptance and change control; reference the PRD or backlog for feature detail rather than copying it.

Can you write a fixed scope of work for an agile project?

Yes. Fix the outcome, constraints, team capacity and decision process, and let the product owner reprioritise backlog items within that capacity. Raise a formal change request only when objectives, constraints, capacity or dates change.

What should be out of scope in a software project?

List anything a reasonable stakeholder might assume is included but is not: extra platforms, integrations, data migration, payments, notifications, languages, content creation and post-launch support. Items nobody would expect do not need listing.

How do you handle scope changes in a software project?

Use a written change-request process: log the request, estimate its effect on effort, timeline and cost, get a named decision-maker to approve or reject it, then update the scope or backlog and record it in a change log.

Related Blogs