Fixed scope development is an engagement in which the vendor and the buyer agree, before any code is written, on exactly what will be built, what will be excluded, and how the result will be accepted. Price and timeline are then set against that agreed scope. It works well when requirements are stable and the outcome can be described precisely. It works poorly when you expect to learn as you build. This guide covers what a fixed scope contains, how to write one that survives contact with reality, and how it compares with time and materials.
TL;DR
- Fixed scope means the deliverables, exclusions and acceptance conditions are written down and approved before work starts, and price follows from them.
- It fits projects with definite requirements, identifiable risks and a buyer who can sign off on a clear outcome. It is a poor fit for products still searching for their shape.
- Most failures come from vague scope statements, missing exclusions and no change-request process, not from the pricing model itself.
- Agile and fixed scope can coexist if scope is tied to goals and increments, with a defined way to trade features in and out.
- If requirements are still moving, time and materials, or a short fixed-scope discovery phase followed by a larger build, is usually the safer path.
Table of Contents
- What fixed scope development means
- What belongs in scope and what does not
- The parts of a fixed scope document
- When fixed scope is the right choice
- The main risks, and who carries them
- Fixed scope versus time and materials
- Can you be agile inside a fixed scope?
- A worked example
- How we think about fixed scope
- Choosing a model with Odesa
- A checklist before you sign
- FAQ
- Sources
What fixed scope development means
In software, project scope is the defined boundary of the work: goals, deliverables, tasks, costs, deadlines, constraints and the conditions under which the result is accepted. It states what the team will do and what it will not. TechTarget’s definition also separates project scope (the work needed to produce the deliverable) from product scope (the capabilities, features and functions of the deliverable). You need both in a fixed scope document: the features you want, and the work the vendor commits to perform to deliver them.

The Project Management Institute’s software extension to the PMBOK Guide describes scope management as ensuring the project includes all the work required, and only the work required. That phrase is a useful test for any fixed scope document. If a task is not needed to deliver the agreed outcome, it does not belong. If a task is needed and missing, someone will pay for it later.
Fixed scope, fixed price and fixed bid
The terms overlap in practice. A fixed price is the commercial term: a set amount for a defined result. Fixed scope is the technical and contractual definition of that result. A fixed bid is simply a vendor’s priced proposal against a scope. A fixed price without a clear scope is a gamble for both sides, because the vendor will price in risk and the buyer will assume more is included than the vendor intended.
What belongs in scope and what does not
A good scope statement is as specific about exclusions as it is about inclusions. Microsoft’s guidance says a scope statement should hold the goal or product scope, the project boundaries, the deliverables, and limitations such as time, budget, resources and regulations. The same guidance stresses that scope defines what a project is doing and what it is not doing.
A practical example comes from Indeed’s explanation of in-scope and out-of-scope work. It describes a mobile app with a six-month delivery, iOS and Android versions, weekly reporting and a $20,000 budget. Marketing and deployment are excluded, so app-store publication, a second app and an email campaign fall outside the agreement. Interface design, coding, usability testing and product documentation sit inside it.
Translated to a typical software engagement, the split looks like this:
| Usually in scope | Often left out unless named |
|---|---|
| Defined features and user flows | Additional platforms or a second product |
| Design, coding and testing for those features | App-store submission and publishing |
| Documentation and handover | Marketing, analytics campaigns, content |
| Agreed integrations with named third-party services | Integrations discovered later |
| A set number of review or revision rounds | Unlimited revisions |
| Defined hosting and environment setup | Ongoing maintenance and support |
If a line item matters to you, write it in. If it matters and you are unsure, write it in the exclusions list so the conversation happens before signing rather than after.
The parts of a fixed scope document
A fixed scope agreement that holds up in practice has six parts. Write each one before you request a price.
- Goal and business outcome. One short paragraph on why the product exists and who uses it. Every requirement should link back to this.
- Deliverables. A list of what will be handed over: working features, source code, documentation, deployed environments.
- Exclusions. Everything adjacent that the price does not cover.
- Acceptance criteria. Testable conditions for each deliverable. See our guide on how to write acceptance criteria that teams can test.
- Timeline and milestones. Dates tied to deliverables, with payment linked to accepted milestones where possible.
- Change-request process. How additions, removals and substitutions are proposed, priced and approved.
Write acceptance criteria before the build
Acceptance criteria are what turn a description into a contract. A criterion such as “the checkout works” cannot be accepted or rejected. A criterion such as “a logged-in user can pay by card, receives a confirmation email within one minute, and sees the order in their history” can. Each deliverable should have a handful of these, written so a tester who has never met the team could pass or fail them. Decide, too, who signs off and how many working days they have to respond. Silence should not be an open-ended state.
If you want a method for setting clear targets while leaving room for iteration, an outcome-first software roadmap helps you separate fixed outcomes from details that can flex.
Trace every requirement to a goal
The PMI paper on the causes of scope creep recommends requirements traceability, for example a traceability matrix, so that each requirement links to a business objective. In a fixed scope project this does two jobs. It lets you cut features that serve no objective when budget pressure arrives, and it gives you a defensible answer when a stakeholder asks for something new.
Plan for change before it happens
The same PMI paper recommends a change-management process to prevent unauthorized additions, and it warns that a process that is too rigid can reject changes that would benefit the project, a failure it calls scope kill. A workable change process has four steps:
- Anyone on the buyer side submits a written request describing the change and the reason.
- The vendor estimates the effect on cost, schedule and other deliverables, usually within a few business days.
- A named decision-maker approves, rejects or defers it.
- The approved change is added to the scope document so the baseline stays accurate.
Microsoft frames the approved scope statement as a shared baseline that aligns the customer, sponsor and team and gives everyone the reference point for judging changes. That is the right way to think about it: the document is not a weapon, it is the shared memory of what was agreed.
When fixed scope is the right choice
The clearest official statement on suitability comes from US federal procurement rules. FAR 16.202-2 says firm-fixed-price contracts suit situations where specifications are reasonably definite and a fair price can be set at the outset. It also says they fit where performance uncertainties can be identified and their cost effect estimated, and the contractor is willing to accept those risks. Those rules govern government buying, but the logic carries over to private software projects.
In plain terms, fixed scope fits when:
- Requirements are stable. You can describe the finished product without guessing.
- The work is well understood. The team has built something similar, and the technology is not experimental.
- The outcome is a defined asset. A marketing site, an integration, a migration, a mobile app with a known feature list.
- You need budget certainty. A board, a grant or a client contract fixes your ceiling.
- You can staff the buyer side. Someone on your team answers questions and approves milestones quickly.
It fits poorly when you are validating a new product, when user feedback will reshape priorities, or when the technical approach is still unproven. Those projects need room to learn, and a fixed scope will either block the learning or turn every discovery into a change order.
The main risks, and who carries them
Under a firm-fixed-price arrangement, FAR 16.202-1 places the maximum risk and responsibility for costs, and the potential for profit or loss, on the contractor. That sounds buyer-friendly, but the risk does not disappear. It changes shape:
- Padded estimates. A vendor carrying cost risk will add contingency to the price. You pay for risks that may never occur.
- Quality pressure. If the vendor is running over, the incentive is to cut corners on testing, documentation or code quality, because the price is fixed.
- Change-order friction. Every new idea becomes a negotiation, and relationships can sour when both sides read the scope differently.
- False certainty. A fixed price protects against overruns in cost, not against building the wrong thing.
The defence is the same in every case: a precise scope, testable acceptance criteria and a candid change process. If you need a way to produce a defensible estimate in the first place, our guide to software project estimation with a 5 to 10 item work breakdown structure walks through it.
Fixed scope versus time and materials
Time and materials (T&M) bills for the hours worked and the resources used, usually at an agreed rate. The buyer carries the cost risk, and gains flexibility in return. In federal commercial-services buying, a T&M contract may be used only when no other authorized contract type is suitable, with the rationale documented and a ceiling price included. Private buyers face no such rule, but the ceiling idea is good practice: set a not-to-exceed figure and review it at every milestone.
T&M also tends to make it easier to change course. A US government field guide on technology buying notes that T&M arrangements allow easier exit clauses, making it simpler to replace a vendor whose performance or skills fall short. For a deeper comparison, see our article on time and materials versus fixed price for engineering project managers.
| Factor | Fixed scope | Time and materials |
|---|---|---|
| Who carries cost risk | Mostly the vendor | Mostly the buyer |
| Best for | Defined, stable requirements | Evolving or exploratory work |
| Budget predictability | High, if scope holds | Moderate, depends on a ceiling and review cadence |
| Flexibility | Low, changes go through change orders | High, priorities can shift each sprint |
| Upfront effort | Heavy: detailed scope before pricing | Lighter: start with a backlog and a team |
| Switching vendors | Harder mid-project | Easier |
Many teams land on a hybrid. They run a short, fixed-scope discovery or design phase, then continue the build on a monthly team or hourly basis. Others fix the scope of a first release and keep later releases flexible.
Can you be agile inside a fixed scope?
The top-ranking discussions for this topic mostly ask this question, and the answer is a qualified yes. The U.S. Digital Services TechFAR Hub explains that Agile contract scope can stay adaptable when work is linked to the product vision or high-level goals in the requirements document. That lets teams learn from user feedback without every change counting as out of scope.
An industry practice guide from the National Defense Industrial Association adds that Agile and fixed-price work can be combined through a cooperative program management process that allows trade-offs within established constraints. Buyer and seller must collaborate on those trade-offs so the final product still delivers the intended business value. And the National Contract Management Association’s April 2023 guidance recommends treating scoping as an activity of its own, then quoting the effort for all of the work or an initial increment.
In practice that means three adjustments:
- Fix the outcomes and the budget, not every feature. Define goals and a prioritized list, and let the team swap items of similar size.
- Work in increments. Price the first release or the first few sprints, deliver working software, then re-plan.
- Keep a backlog with a must-have line. Anything above the line is fixed. Anything below it is the trade-off space.
This does not give you everything. A truly fixed list of features, date and price leaves no room to adapt, and something will give: quality, schedule or the relationship. Agree up front which of the three constraints can move.
A worked example
Suppose a growth-stage company wants a customer portal with login, invoice history, payment by card and an admin view. A weak scope says: “Build a customer portal.” A usable one lists four user roles and flows, names the payment provider, states that data migration of existing invoices is included for the past 24 months, excludes native mobile apps and email marketing, specifies two design revision rounds, and defines acceptance for each flow in testable terms. It adds a milestone plan with payment tied to accepted milestones, and a change process with a two-business-day response time for estimates.
Now a stakeholder asks for a mobile app. Under the weak scope, that is an argument. Under the strong one, it is a change request with a price, a date impact and a yes or no.
How we think about fixed scope
We work with growth-stage companies that hire senior engineers from Eastern Europe, and we see the same pattern across engagements. Fixed scope succeeds when the buyer has done the thinking before the contract, and it fails when the contract is asked to do the thinking for them. We would not push a founder with a half-formed product into a fixed-price build. We would rather start with a defined first increment, or place engineers on an hourly basis so priorities can shift as users respond.
We also believe the quality of a project depends on who is matched to it. For scoped work, we involve the founder directly in understanding the requirements, so the scope document reflects what you actually need, not just what is easy to price. A clear acceptance list, independent testing before release and a candid change process protect both sides more than any pricing model does.
— Editorial Team
Choosing a model with Odesa
Which model fits depends on how settled your requirements are. If they are well defined, we can scope custom development with you. If you are still discovering the product, staff augmentation starts from 45 USD per hour and lets senior engineers join your team and adapt as priorities change. Our pricing page lists all engagement types, and the custom development cost guide gives ranges for scoped projects.
Fixed-scope work benefits from an independent check before sign-off. Our Human Release Check is a 1500 USD one-off review of a release by real testers, which maps neatly onto the acceptance step of a milestone. To discuss which model fits your project, start at odesa.co.
A checklist before you sign
- Can you describe the finished product in one page, without caveats?
- Does every deliverable have acceptance criteria a stranger could test?
- Are exclusions written down, including platforms, integrations, hosting and maintenance?
- Is payment tied to accepted milestones rather than elapsed time?
- Does the change process name who approves, and how fast estimates arrive?
- Do you know which of cost, date and feature set can move if something goes wrong?
- Is there a plan for who owns the code and documentation at handover?
If you answer no to more than two, tighten the scope or choose a flexible model for the unclear part. If you are weighing outsourcing in general, our comparison of staff augmentation and outsourcing and the guide on offshore development risks cover the adjacent decisions.
FAQ
What is the difference between a fixed price project and fixed scope development?
Fixed price is the commercial term: a set amount of money. Fixed scope is the definition of what that money buys. They normally travel together, but a fixed price on a vague scope invites disputes, because each side can read the deliverables differently.
What is the difference between in-scope and out-of-scope work?
In-scope work is everything the agreement commits the vendor to deliver, such as the agreed features, design, coding, testing and documentation. Out-of-scope work is anything not named, such as extra platforms, app-store publishing or marketing. Out-of-scope requests are handled through a change request with its own price and timeline.
Can a fixed scope project still be agile?
Yes, if the scope is tied to goals and increments rather than a frozen feature list. Agree a prioritized backlog, deliver in short cycles, and let the team trade items of similar size within the budget. Federal and industry guidance on Agile contracting supports this approach.
When should I choose time and materials instead?
Choose it when requirements are likely to change, when you are testing a new product with users, or when the technical approach is unproven. Set a ceiling and review spend at each milestone so you keep budget control without freezing the scope.
Sources
- What is a project scope? (TechTarget)
- Best practices for managing project scope (Microsoft Support)
- Project Scope Management, Software Extension to the PMBOK Guide
- Top five causes of scope creep (PMI)
- Subpart 16.2, Fixed-Price Contracts (Acquisition.gov)
- FAR 12.207 Contract type (Acquisition.gov)
- De-risking Government Technology: Federal Agency Field Guide
- Contract Modifications for Agile and Digital Services (TechFAR Hub)
- An Industry Practice Guide for Agile on Earned Value Management (NDIA)
- Scoping and Pricing Agile Software Development (NCMA)
- In Scope vs. Out of Scope Meaning With Examples (Indeed)
Recommended
- Team Extension Model: How It Works and When to Use It
- Dedicated Development Team: When It Fits and What It Costs
- How to Manage Offshore Developers Without Micromanaging
This article may have used AI tools in the writing process. Facts, figures, and recommendations can be wrong or out of date. Do not treat this as professional advice.

