Yury Pukhov, YuSMP Group
Yury Pukhov CEO & Mobile Engineering Lead, YuSMP Group
Add YuSMP as a preferred source on Google
TL;DR: A software development scope of work (SOW) is the document that fixes what a vendor will build, what is excluded, how each deliverable is accepted, the milestones, assumptions and the change process. Write it after discovery, pair every deliverable with a testable acceptance criterion, list exclusions explicitly and match the level of detail to your pricing model.

A software development scope of work is the part of a project agreement that says, in plain language, what will be delivered, by when, to what standard and what is left out. It is the page both sides open when someone asks "was this included?" and the page a project manager reads before approving an invoice. A good one prevents arguments; a vague one creates them.

Most disputes in outsourced projects are not about code quality. They start when the client and the vendor remember the scope differently. That is why teams offering custom software development on a fixed scope spend real time on the SOW before writing a line of code: the document is what makes a fixed price and a fixed date possible at all.

This guide is written for founders, product owners, procurement leads and project managers who need to write, review or negotiate a scope of work for software development. It covers:

  • what a software SOW is and how it differs from a statement of work, an MSA and an SRS;
  • the sections every scope of work for software development should contain;
  • an 8-step process to write one, with examples of weak and strong wording;
  • how fixed price, time and materials and agile delivery change the document;
  • scope creep, change control and new 2026 issues such as AI-assisted coding;
  • a scope of work template for software development, a filled example and a review checklist.

What is a software development scope of work?

A software development scope of work is a written definition of the work a development team will perform and the results it will hand over: features, deliverables, milestones, acceptance criteria, assumptions, exclusions and responsibilities. It turns a product idea into commitments that both the client and the vendor can check.

In practice the SOW answers six questions:

  • Why: which business outcome the software must support.
  • What: which features, documents and environments will be delivered.
  • What not: which work is explicitly out of scope.
  • When: the milestones and the dates or sprint numbers attached to them.
  • How we know it is done: acceptance criteria and the sign-off procedure.
  • What happens if things change: the change request process and its effect on price and time.

The scope of work is usually attached to a contract as an exhibit or schedule. It can be three pages for a landing page or forty pages for a multi-role platform. Length is not the goal; the goal is that a third party could read it and decide whether a given task was included.

Scope of work vs statement of work vs MSA vs SRS

A scope of work describes the work itself, while a statement of work is the wider project document that contains the scope plus price, schedule and commercial terms. In everyday use the two terms are often swapped, and "SOW" is used for both. What matters is that the four documents below do different jobs and should not contradict each other.

DocumentWhat it definesWho relies on itTypical length
Master services agreement (MSA)Legal terms for the whole relationship: liability, IP ownership, confidentiality, payment terms, terminationLegal and procurement10 to 30 pages, signed once
Statement of workOne project under the MSA: scope, deliverables, schedule, price, payment milestones, rolesProject sponsors and both delivery teams5 to 40 pages per project
Scope of workThe work section: features, deliverables, exclusions, acceptance criteria, assumptionsProject managers, developers, QA2 to 20 pages, often inside the statement of work
Software requirements specification (SRS) or PRDDetailed functional and non-functional requirements, user stories, data and integration detailsProduct owners, architects, engineers10 to 100+ pages, may evolve during delivery

The practical rule: the MSA wins on legal questions, the SOW wins on what is being bought, and the SRS or product requirements document (PRD) fills in detail the SOW references. If you are still choosing a vendor, the document you send first is a request for proposal; our guide to writing an RFP for software development covers that earlier step.

Why does a software project need a scope of work?

A software project needs a scope of work because unclear scope is the most common cause of budget and schedule overruns, and the SOW is the cheapest place to remove that uncertainty. Fixing a misunderstanding in a document costs an hour; fixing it after the feature is built costs a sprint.

FindingFigureSource
Large IT projects running over budget, on average45%McKinsey & University of Oxford study of 5,400 IT projects (2012)
Value delivered compared with what was predicted56% lessMcKinsey & University of Oxford (2012)
Projects that experienced scope creep52%PMI Pulse of the Profession (2018)
Estimate error at the very start of a projectUp to 4x either waySteve McConnell, "cone of uncertainty" (Software Estimation, 2006)

Beyond the numbers, a scope of work does three concrete things for each side:

  • For the client: it makes quotes from different vendors comparable and gives a clear basis to accept or reject work.
  • For the vendor: it protects the team from unpaid extra work and lets it plan people and sprints.
  • For both: it creates a shared vocabulary, so "admin panel" or "integration" means the same thing on both sides of the table.

Who writes the scope of work?

The vendor usually drafts the software development scope of work, and the client reviews, edits and approves it. The vendor knows how to translate features into deliverables and estimates; the client knows the business goals and constraints. A draft written by only one side tends to be either too vague or too technical.

A typical split of responsibilities looks like this:

  • Client product owner or sponsor: business objectives, priorities, must-have versus nice-to-have features, decision makers.
  • Vendor project or delivery manager: structure of the document, milestones, assumptions, change process.
  • Vendor solution architect or tech lead: technical scope, integrations, environments, non-functional requirements.
  • Client legal or procurement: consistency with the MSA, payment milestones, IP and confidentiality references.

The best input for a strong draft is a short discovery phase: one to four weeks of workshops, user flows and technical checks. Without it, the SOW is built on guesses, and guesses become change requests later.

What should a software development scope of work include?

A complete software development scope of work includes twelve sections: objectives, scope summary, deliverables, functional requirements, non-functional requirements, exclusions, assumptions and dependencies, timeline and milestones, acceptance criteria, roles, change control and post-launch support. Skipping any of them leaves a question that will be answered later, usually at a higher price.

SectionWhat to writeWhat to check before signing
1. Background and objectivesThe business problem and 2 to 4 measurable goalsEach feature traces back to at least one goal
2. Scope summaryOne paragraph describing the product and its usersA new team member understands the project in one minute
3. DeliverablesSoftware, source code, designs, documentation, environmentsEvery deliverable has an owner and a format
4. Functional requirementsFeatures grouped by user role or moduleRequirements are testable, not adjectives
5. Non-functional requirementsPerformance, security, accessibility, browsers and devices, uptimeTargets have numbers (for example, page load under 2 seconds)
6. Out of scopeWork that will not be done in this phaseCommon "assumed" items are listed explicitly
7. Assumptions and dependenciesWhat the client provides and what external systems must be availableEach dependency has a date and an owner
8. Timeline and milestonesPhases, sprints or dates tied to inspectable resultsMilestones end in something you can see or test
9. Acceptance criteriaHow each deliverable is reviewed, tested and signed offReview windows and "deemed accepted" rules are stated
10. Roles and communicationNamed contacts, meeting cadence, tools, escalation pathOne decision maker per side
11. Change controlHow new requests are estimated, approved and billedNo change starts without written approval
12. Handover and supportCode transfer, documentation, warranty period, maintenance optionsWarranty length and response times are defined

Where price, IP and legal terms belong

Price and payment schedule usually live in the statement of work or contract rather than in the scope section itself. If you combine them in one document, tie every payment to a milestone from section 8, not to calendar dates alone. IP ownership and confidentiality belong in the MSA or a separate NDA for software development; the SOW should reference them, not restate them.

How to write a scope of work for software development: 8 steps

To write a scope of work for software development, start from business goals, break the product into deliverables, define acceptance for each, list exclusions and assumptions, attach milestones and agree on a change process. The eight steps below follow the order in which decisions depend on each other.

Software team mapping project deliverables and milestones with colored sticky notes on a glass wall
  1. State the objectives. Write two to four outcomes the software must achieve, such as "reduce manual order entry by sales staff" or "let partners download invoices without emailing support". Avoid goals like "modern platform" that cannot be checked.
  2. Describe users and roles. List every user type (customer, admin, partner, support agent) and what each one must be able to do. Roles drive most of the effort in business software.
  3. Break the product into deliverables. Group features into modules and name the tangible outputs: web app, mobile app, admin panel, API, design files, test reports, deployment scripts, user guide.
  4. Write requirements that can be tested. For each module, list functional requirements as user actions and system responses. Add non-functional requirements with numbers.
  5. List exclusions, assumptions and dependencies. Write down what will not be built, what the client supplies (content, API keys, test accounts) and which third parties must cooperate.
  6. Attach milestones and acceptance criteria. Tie each milestone to a demo, a test run or a deployed environment, and define how long the client has to review it.
  7. Define the change process. Describe how a new request is submitted, estimated, approved and scheduled, and who can approve it.
  8. Review with both teams and sign. Walk through the document line by line with engineers and the client's decision maker. Every "we assumed" in that meeting becomes a sentence in the SOW.

Where estimates fit in

Estimates come in at step 6. If you want to understand how vendors turn the scope into hours and price, read our software project estimation guide before you compare quotes.

How detailed should requirements be in an SOW?

Requirements in a scope of work should be detailed enough that a tester could check them, but not so detailed that the SOW becomes a full specification. A useful test: if two engineers could build the same requirement in ways that differ by more than a week of effort, the requirement needs another sentence.

TypeToo vagueTestable
FunctionalUsers can manage their account.Users can register with email and password, reset the password by email link, change their email after re-entering the password and delete the account, which removes personal data within 30 days.
FunctionalAdmin panel for orders.Admins can search orders by number, customer email and date range, change status among 5 defined statuses and export the filtered list to CSV.
IntegrationIntegrate with the CRM.New customers and orders sync one way to the client's CRM via its REST API within 5 minutes; field mapping is attached as Appendix B.
PerformanceThe app should be fast.Key pages load in under 2.5 seconds (Largest Contentful Paint) on a mid-range phone over 4G at the 75th percentile.
SecurityThe system must be secure.Passwords are hashed with bcrypt or Argon2, all traffic uses TLS 1.2+, and the release passes an OWASP Top 10 review before launch.
AccessibilityAccessible design.Public pages meet WCAG 2.2 level AA, checked with automated tools and a manual keyboard test.

Large or regulated projects keep the full requirement list in a separate document and reference it from the SOW by version number. If you maintain hundreds of requirements, a dedicated tool helps; see our comparison of requirements management software.

Weak vs strong scope of work wording

Strong scope of work wording uses numbers, named items and observable outcomes, while weak wording relies on adjectives such as "user-friendly", "scalable" or "complete". Weak words are the source of most "but we expected" conversations. The pairs below show typical fixes.

Weak wordingWhy it causes troubleStronger wording
"Full e-commerce functionality"No limit on what "full" includes"Catalog with up to 3 levels of categories, cart, checkout with card payments via one provider, order history"
"Support for all devices"Thousands of device and browser combinations"Latest two versions of Chrome, Safari, Edge and Firefox; iOS 17+ and Android 12+"
"Design as discussed"Memory is not a specification"Designs per Figma file v1.3 approved on 10 March; up to 2 revision rounds per screen"
"Data migration from the old system"Volume, quality and mapping unknown"One-time migration of customers and orders from the MySQL export provided by the client; up to 200,000 records; cleansing excluded"
"Ongoing support"No end date and no response times"60-day warranty for defects; critical issues answered within 4 business hours"
"Integration with third-party services"Every integration becomes a debate"Stripe payments, SendGrid email, Google Analytics 4; any other integration is a change request"

How does the pricing model change the scope of work?

The pricing model decides how much detail the scope of work needs: a fixed-price project needs a precise, closed scope, while time and materials or a dedicated team needs a clear goal, a backlog and rules for priorities. Using a fixed-price SOW with a loose scope is the most common way to start a conflict.

Pricing modelWhat the SOW must nail downWhat can stay flexibleBest fit
Fixed priceEvery feature, exclusion, acceptance criterion and number of revision roundsInternal technical decisionsWell-understood products, MVPs after discovery, clear compliance scope
Time and materialsGoals, team composition, rates, reporting, budget caps and review pointsFeature list and order of deliveryEvolving products, research-heavy work, legacy modernization
Dedicated teamRoles, seniority, availability, replacement rules, onboarding, notice periodsAlmost all product scopeLong-term product development with an in-house product owner
Hybrid (fixed discovery or MVP, then T&M)Fixed scope for phase 1; rate card and process for phase 2Everything after phase 1New products that need a reliable first release

For reference, at YuSMP Group fixed-scope custom builds start at $1,100 for a landing or small build (2 to 4 weeks), $2,900 for a corporate system with roles and integrations (6 to 10 weeks), $5,800 for an online store or marketplace (10 to 16 weeks) and $10,400 for a portal or multi-role web service (14 to 22 weeks). Each of these prices is attached to a written scope, which is exactly why the SOW matters. A detailed comparison of the models is in our article on time and materials vs fixed price vs dedicated team.

Can a scope of work be agile?

Yes. An agile scope of work fixes the goal, the budget, the team and the way priorities are set, and leaves the exact feature list to a backlog that is refined each sprint. It replaces "we will build features A to Z" with "we will deliver the highest-value items from this backlog within this budget and time box".

An agile SOW usually contains:

  • a product goal and a measurable definition of success for the release;
  • an initial prioritized backlog with must-have items clearly marked;
  • sprint length, ceremonies and who acts as product owner on the client side;
  • a shared definition of done (code reviewed, tested, deployed to staging, documented);
  • a budget or sprint cap and the review points where the client can stop, continue or re-plan.

This format works well for an MVP development project where learning from users is part of the plan. It works badly when the client needs a guaranteed feature list on a fixed date. In that case, a short fixed discovery followed by a fixed-scope first release is safer. Our agile software development guide explains the delivery side in more detail.

How to control scope creep after the SOW is signed

Scope creep is controlled by a written change process that every new request must pass through, so that each change gets an estimate, a decision and a visible effect on budget or timeline. Creep rarely arrives as one big request; it arrives as many small "quick" additions that nobody records.

Client signing off a project milestone agreement while a manager points to the delivery timeline on paper

A simple change control process has four steps:

  1. Log: every request goes into one list, with who asked and why.
  2. Classify: the project manager marks it as included (already in scope), a defect, a change or deferred to a later phase.
  3. Estimate: for changes, the team gives effort, cost and schedule impact, and what could be swapped out instead.
  4. Approve in writing: the named decision maker approves or rejects it; only then does work start.

Two habits make the process work. First, allow swaps: on fixed-price work, a new feature can often replace an unbuilt one of similar size without changing the price. Second, keep a small contingency (often 10 to 15% of the budget) for changes the team already expects. Scope creep is one of the risks we cover in our overview of risks in software development.

What changes in a scope of work in 2026: AI-assisted development

In 2026 a scope of work should state whether the vendor may use AI coding assistants, how generated code is reviewed and who owns it, and whether any AI features in the product itself are in scope. These questions now come up in most procurement reviews.

Do not assume AI tools automatically shorten timelines. A randomized trial published by METR in July 2025 found that experienced open-source developers took 19% longer on real tasks when using AI tools, even though they expected to be faster. Results vary by team and task, so treat AI speed-ups as something to prove, not something to price in.

Clauses worth adding:

  • Tool use: which AI assistants are allowed and whether client code or data may be sent to external models.
  • Review: generated code goes through the same code review and testing as human-written code.
  • IP and licensing: the vendor confirms that delivered code is free of license conflicts and that ownership transfers as in the MSA.
  • AI features: if the product includes AI (chatbots, search, summaries), the SOW names the model provider, usage-based costs, accuracy targets and who pays for inference.

Scope of work template for software development

A scope of work template for software development is a fixed outline of headings with prompts for what to write under each one. Copy the structure below into your document and replace each prompt with project facts; delete nothing until you have decided that a section truly does not apply.

  1. Project overview. Client, vendor, project name, document version, date, related MSA or contract number.
  2. Background and objectives. The problem in 3 to 5 sentences; 2 to 4 measurable goals.
  3. Users and roles. A table of user types and their main tasks.
  4. Scope of work. Modules and features, grouped by role or by area; link to the SRS or PRD if one exists.
  5. Deliverables. A table: deliverable, format, owner, milestone.
  6. Non-functional requirements. Performance, security, accessibility, supported platforms, availability, data retention.
  7. Out of scope. A bulleted list of excluded work.
  8. Assumptions and dependencies. Client inputs, third-party services, access and environments, with due dates.
  9. Timeline and milestones. Phases with start and end dates or sprint numbers and the result of each.
  10. Acceptance criteria and sign-off. Test approach, review window (for example, 5 business days), what counts as a blocking defect.
  11. Project governance. Contacts, meeting cadence, reporting, tools, escalation.
  12. Change management. How changes are requested, estimated, approved and billed.
  13. Handover, warranty and support. Source code transfer, documentation, warranty period, optional maintenance.
  14. Commercial reference. Price or rate card and payment milestones (or a reference to the statement of work that contains them).
  15. Signatures. Names, titles and dates for both parties.

Legal clauses such as liability caps, warranties of title and termination rights belong in the contract. Our software development contract guide lists the clauses that should sit around the SOW.

Software development scope of work example

The example below shows how a filled scope of work reads for a typical B2B project: a customer portal for a distributor. It is an illustrative excerpt, not a real client document, and is shortened to the sections where wording matters most.

SectionExample text
ObjectiveLet 400 business customers check stock, place repeat orders and download invoices without contacting sales, cutting phone and email orders by 50% within 6 months of launch.
Users and rolesCustomer buyer, customer admin (manages buyers in their company), distributor sales manager, distributor administrator.
In scopeResponsive web portal; login with email and password plus optional TOTP; product search with live stock from ERP; cart and repeat order from history; invoice list with PDF download; customer admin user management; distributor admin panel for customers and price lists.
Out of scopeNative mobile apps; online card payments; ERP changes; content writing and translation; data cleansing of the ERP customer list.
IntegrationRead stock and prices, write orders via the ERP's existing REST API; the client provides a sandbox with test data by week 2.
Non-functionalSearch results under 1.5 seconds for 95% of queries; WCAG 2.2 AA for customer pages; daily backups kept 30 days; hosting in the EU.
MilestonesM1 week 3: approved designs. M2 week 8: search and ordering on staging. M3 week 13: invoices and admin panel on staging. M4 week 16: production launch after UAT.
AcceptanceClient reviews each milestone within 5 business days; a milestone is accepted when no critical or major defects remain open; silence after 5 days counts as acceptance.
Change controlChanges requested in writing by the client product owner; vendor replies with estimate within 3 business days; work starts after written approval.
Support60-day defect warranty after launch; optional monthly maintenance quoted separately.

Software SOW review checklist before you sign

Before you sign a software development scope of work, check that every deliverable can be tested, every exclusion is written down and every dependency has an owner. The ten questions below catch most problems in a 30-minute review.

  1. Does every feature trace back to a stated objective?
  2. Is every deliverable named with its format and milestone?
  3. Can a tester check each requirement without asking what it means?
  4. Do non-functional requirements have numbers?
  5. Is there an explicit out-of-scope list, including migration, content and integrations?
  6. Does each client dependency have a due date?
  7. Does each milestone end in something you can see, run or test?
  8. Are the review window and the acceptance rule defined?
  9. Is the change process written, with a named approver on each side?
  10. Are code handover, documentation and the warranty period stated, and is IP ownership referenced to the MSA?

If a vendor resists answering these points in writing, treat it as a signal about how the project will run. Our guide on how to choose a software development company lists other signals worth checking.

Frequently asked questions

What is a software development scope of work?

A software development scope of work is the document that defines what a development team will build and hand over: objectives, features, deliverables, exclusions, assumptions, milestones, acceptance criteria and the change process. It is usually attached to the contract and is the reference both sides use to decide whether a task was included.

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

A scope of work describes the work and deliverables, while a statement of work is the broader project document that also covers price, payment schedule, timeline and commercial terms. In software projects, the scope of work is often a section inside the statement of work, and both are commonly abbreviated as SOW.

Who should write the scope of work for a software project?

The development vendor usually drafts the scope of work and the client reviews and approves it. The vendor translates features into deliverables and estimates, and the client confirms objectives, priorities and constraints. The strongest drafts follow a short discovery phase with both teams.

How long should a software scope of work be?

A software scope of work is typically 2 to 20 pages. A small website may need two or three pages, while a multi-role platform with integrations can need twenty or more, often with a separate requirements document attached. The right length is the shortest one that leaves no open questions about what is included.

Can you change a scope of work after signing?

Yes, through a change request. The requested change is logged, estimated for cost and schedule impact, and approved in writing by the named decision maker before work starts. On fixed-price projects, a new feature can often replace an unbuilt feature of similar size without changing the total price.

Is a scope of work legally binding?

A scope of work is binding when it is signed and attached to or referenced by a contract, such as a master services agreement. On its own it describes the work, while the contract supplies legal terms like liability, IP ownership and termination. Have legal counsel review both documents together.

What is the most common mistake in a software SOW?

The most common mistake is vague requirements without acceptance criteria, followed by a missing out-of-scope list. Phrases like "full functionality" or "support for all devices" cannot be tested, so the client and vendor end up disagreeing about whether the work is finished.

Sources: project overrun data and standards

Published 16 November 2026. Statistics come from the cited sources. The scope of work example is illustrative and does not describe a real client. YuSMP Group prices are starting prices published on our service pages; final quotes depend on scope. This article is not legal advice.