Free template · statement of work

Statement of work for software development

A complete statement of work for building a web app, written out in full: what gets delivered, how each milestone is accepted, what the client has to provide, how changes are handled, and who owns the code. Copy it, or open it in Devposal and send it as a link your client can sign.

Sections
12
Estimate
13 lines, 192 hours
Example total
$24,288.00
Payments
30% / 20% / 30% / 20%
Proposal

Statement of work: Fieldnote MVP

Prepared for Fieldnote

Investment
$24,288
Payments
4 stages

Purpose

This statement of work (SOW) sets out what we will build for Fieldnote, how each part will be accepted, what it costs, and how changes are handled. It sits under the services agreement between us; if the two disagree, the agreement wins.

The goal: a web app where field teams record site visits with notes and photos, work offline on a phone, and share reports with their clients, live within 8 weeks of kickoff.

Deliverables

Discovery and design

  • Kickoff workshop and a written product briefS-1
  • Clickable wireframes for every screenS-2
  • A small design system (type, colour, components) in FigmaS-3

Product

  • Accounts: email sign-in, password reset, team invitations and roles (owner, member)S-4
  • Site visits: create, edit and archive visits with notes, photos and a locationS-5
  • Offline drafts on mobile browsers, synced when the connection returnsS-6
  • Search across visits by site, date and keywordS-7
  • Shareable visit reports (read-only link and PDF)S-8

Billing

  • Stripe subscriptions with a 14-day trial, upgrades, cancellations and invoicesS-9

Launch

  • Admin dashboard: teams, usage and subscriptionsS-10
  • Production deployment with monitoring and error alertsS-11
  • Handover documentation and a recorded walkthroughS-12

Acceptance criteria

Each milestone is accepted when its criteria are met on the staging site. You have 3 business days to accept or list what's missing; silence after that counts as acceptance.

  1. Design approval: wireframes cover every screen in the deliverables, and the design system is applied to three key screens.
  2. Staging sign-off: every product and billing deliverable works on staging, on the latest Chrome, Safari and Firefox and on a phone, with test data you can try.
  3. Launch: production is live on your domain, payments run in live mode, error alerts reach your inbox, and the handover documents are delivered.

Estimate

Billed against the lines below. A 15% contingency covers the unknowns of a first version and is only invoiced if it's used.

TaskHoursRateAmount
Discovery and design · 36 h$3,960.00
Kickoff workshop and product brief6$110.00$660.00
Wireframes for every screen14$110.00$1,540.00
Design system and key screens16$110.00$1,760.00
Product · 92 h$10,120.00
Accounts, teams and roles18$110.00$1,980.00
Site visits with notes and photos30$110.00$3,300.00
Offline drafts and sync20$110.00$2,200.00
Search10$110.00$1,100.00
Shareable reports (link and PDF)14$110.00$1,540.00
Billing · 18 h$1,980.00
Stripe subscriptions and trial18$110.00$1,980.00
Launch · 46 h$5,060.00
Admin dashboard16$110.00$1,760.00
Automated tests and accessibility pass16$110.00$1,760.00
Production setup, monitoring and alerts8$110.00$880.00
Handover documents and walkthrough6$110.00$660.00
Subtotal$21,120.00
Contingency (15%)$3,168.00
Total$24,288.00

Timeline

  • Weeks 1–2: discovery and design, ending in design approval
  • Weeks 3–6: build, with a staging demo every Friday
  • Week 7: testing and acceptance
  • Week 8: launch and handover

The dates assume the client dependencies below are met on time.

Payment schedule

Invoices are due within 14 days. Work on the next milestone starts when the previous invoice is paid.

  1. DepositOn signing$7,286.4030%
  2. Design approvalEnd of week 2$4,857.6020%
  3. Staging sign-offEnd of week 7$7,286.4030%
  4. Launch and handoverWeek 8$4,857.6020%

Client dependencies and assumptions

  • Access to your domain's DNS, a Stripe account and the app's email sender by the end of week 1
  • Copy and example data for the demo screens by week 3
  • One person who can approve each milestone, and feedback within 2 business days
  • Hosting and third-party services (estimated at $40–80 a month at launch) are billed to your accounts
  • Up to 20 test users during the build

Out of scope

  • Native iOS or Android apps (the web app works on phones; native apps can be quoted separately)
  • Single sign-on (SAML/SSO) and custom roles beyond owner and member
  • Moving data from an existing system
  • Copywriting, illustration and marketing pages
  • Support after the warranty period (available as a monthly retainer)

Environments and handover

The code lives in a repository in your GitHub organisation from the first day. There are two environments: staging (for demos and acceptance) and production. After the final payment we hand over all credentials, remove our own access on request, and walk your team through the code, deployment and monitoring.

Change control

Anything not listed above is a change. Send it in writing; within 2 business days you get its effect on cost and dates. Approved changes are added as a new version of this statement of work for you to approve, so there is always one current, signed scope.

Ownership, warranty and terms

  • Ownership: the code, designs and documents become yours on final payment. Open-source libraries keep their own licences.
  • Warranty: for 30 days after launch, we fix defects against the acceptance criteria at no charge.
  • Late payment: invoices unpaid 14 days after the due date pause the work.
  • Ending early: either side can end this SOW with 10 days' notice. You pay for work done to that date plus 20% of the current milestone, and receive everything built so far.
  • Confidentiality: we keep your business information private and use the project in our portfolio only with your permission.

Approval

Approving this statement of work confirms the deliverables, acceptance criteria, price and terms above. Work starts on the first Monday after the deposit clears.

A worked example for a fictional client. Every word and number is yours to change.

What each part is for, and what to write

  1. Purpose: one paragraph, with the outcome and the date

    Say what will exist at the end and by when (“live within 8 weeks of kickoff”). If you have a master services agreement, say which document wins when they disagree. That one sentence prevents most arguments.

  2. Deliverables: things you can point at

    List outputs, not activities: “search across visits by site, date and keyword”, not “implement search”. Group them by phase so they line up with the payment milestones. If a client can't check it on a screen, it probably isn't a deliverable.

  3. Acceptance criteria: the part most templates leave out

    Every milestone needs a test the client can run, and a deadline for them to run it. Without it, “done” means whatever the client feels on the day, and your last invoice waits.

    Name the environment (staging), the browsers and devices, and what silence means after the review window. Three business days is common.

  4. Estimate and contingency: show the work

    A line per piece of work, with hours and a rate, lets the client see where the money goes and trade scope for price. Add contingency as its own visible line (10–20% for a first version) instead of padding every line in secret. Developers on Hacker News report padding anywhere from 1.25× to 4×; an open contingency line is easier to defend.

  5. Client dependencies: what you need, and by when

    Access to DNS, payment and email accounts, content, test data, one decision-maker, and a feedback window. Tie the timeline to these in writing (“the dates assume…”), so a late login doesn't become your late delivery.

  6. Out of scope: say what you won't do

    Native apps, single sign-on, data migration and copywriting are the usual surprises on a web build. Listing them, with “can be quoted separately”, turns a future argument into a future sale.

  7. Environments and handover: where the code lives

    Put the repository in the client's organisation from day one and hand over credentials after the final payment. Clients worry about being locked in; this paragraph answers that before they ask.

  8. Change control: one current, signed scope

    Every change in writing, with its cost and date impact, approved before work starts. In Devposal an approved change goes out as a new version of the same document, with a list of what changed, and the client approves it again.

  9. Ownership, warranty and ending early

    Ownership passes on final payment; open-source keeps its licences. A 30-day warranty against the acceptance criteria is fair to both sides. A kill fee (work done plus a share of the current milestone) protects you if the project stops halfway.

Questions people ask

What should a statement of work include?

At minimum: the purpose, the deliverables, acceptance criteria for each milestone, the timeline, the price and payment schedule, what the client must provide, what's out of scope, how changes are handled, and who owns the work. The example above has all of them, written out.

Is a statement of work legally binding? Is it the same as a contract?

A signed SOW can be binding on its own if it has the essentials of an agreement (who, what, price, acceptance). Many teams sign a short master services agreement once and a new SOW per project, with the agreement covering liability and law. This isn't legal advice; for large projects, have a lawyer read your agreement once.

What's the difference between a statement of work and a scope of work?

The scope of work is one section: what will be delivered. The statement of work is the whole document around it: scope plus acceptance, timeline, price, payments, dependencies and terms.

Can one contract cover several statements of work?

Yes, and it's the common setup for ongoing clients: one master agreement, then a short SOW for each project or phase. Each SOW only needs the project-specific parts.

What happens if the scope changes after the SOW is approved?

Use the change-control clause: the client asks in writing, you reply with the effect on cost and dates, and nothing extra starts until they approve. The approved change becomes a new version of the SOW, so there's always one current scope everyone signed.

How much contingency should a software SOW include?

10–20% is typical for a first version with unknowns (third-party APIs, offline sync, migrations). Show it as its own line and only invoice it if it's used. Clients accept a visible buffer far more easily than inflated line items.

Related