What a Software Development RFP Is For
A request for proposal (RFP) is the document you send to a shortlist of development companies so they can propose how they'd build your software, what it would cost and who would do it. Its real job is to get proposals you can compare. If three vendors answer three different questions, you're choosing on gut feel, and the RFP has failed even if it was beautifully written.
This guide is for the person who has to write that document: a founder, product owner, CTO or operations lead who has already decided to work with an external partner. If you haven't made that call yet, our build vs buy vs outsource decision guide covers it first. By the end of this guide you should have a complete RFP, a timeline for running it, and a scorecard ready before the first proposal arrives.
RFI, RFQ or RFP: which one you need
Choosing the right request document
| Document | Use it when | What you get back |
|---|---|---|
| RFI (request for information) | You don't yet know what's possible or which vendors are credible | Capabilities, approach ideas, rough ranges; no commitment |
| RFQ (request for quotation) | The work is fully specified and price is the main difference | Prices for a defined scope |
| RFP (request for proposal) | You know the problem and outcomes but want vendors to propose the solution | Approach, team, plan, price and assumptions you can compare |
Most custom software projects need an RFP, because the solution isn't fully known yet. An RFQ only works when someone has already done the design and specification work. For a small, well-understood job, such as a marketing site or a short fixed task, a formal RFP is often more process than the project deserves; a clear brief and two or three conversations will get you further.

Decisions to Make Before You Write
Three decisions shape every section of the RFP. Make them first, write them down, and get them approved internally. Changing any of them after proposals arrive forces vendors to re-quote and wastes everyone's time.
1. Your budget range, and whether to share it
Share a range. Without one, vendors guess at the scale you have in mind, and you get one proposal for a lean first release and another for an enterprise platform. A range lets vendors tell you what they'd build for that money, which is exactly the comparison you want. If you're unsure what's realistic, our mobile app development cost guide explains how scope, platforms and team location drive cost.
2. The contract model
The contract model decides who carries the risk of estimates being wrong, so decide it before vendors price anything. US federal acquisition rules give clear definitions that work well outside government too. A firm-fixed-price contract places "maximum risk and full responsibility for all costs" on the contractor. A time-and-materials contract pays for hours at agreed rates, is meant for work that can't be estimated reliably up front, and must carry a ceiling price.
Contract models compared
| Model | Works best when | Watch out for |
|---|---|---|
| Fixed price | Scope is clear and stable, such as a defined first release after a discovery phase | Vendors add risk margin; every change becomes a change request |
| Time and materials with a cap | Scope will evolve and you want to reprioritise as you learn | Needs active product ownership and regular budget tracking on your side |
| Dedicated team (monthly) | Long-running product work with a continuous backlog | You manage priorities; output depends on your direction |
| Fixed-price discovery, then T&M or fixed build | The problem is clear but the solution isn't yet | Make discovery outputs explicit so they're reusable with any vendor |
A paid discovery phase followed by a build quote is often the most honest option for a new product, because nobody can price accurately what nobody has designed. If your work is ongoing rather than a single project, a dedicated development team may suit better than a project contract. The delivery method matters here too; our overview of software development methodologies explains how agile and fixed-scope approaches change what a contract can promise.
3. Who decides, and who scores
Name one accountable decision owner and a small scoring panel of three to five people: usually the product owner, a technical lead, someone from the business team that will use the software, and someone who understands the commercial terms. The people who score proposals should help write the RFP, so they're judging answers to questions they actually care about.
What to Put in the RFP, Section by Section
The template below is the core of this guide. Use the sections in this order, and keep the whole document to roughly 8 to 15 pages. Longer RFPs rarely get better answers; they get longer proposals that are harder to compare. The third column shows how a fictional company, introduced in the next chapter, filled each section.
Software development RFP template, with a filled example
| Section | What to include | Example (Harbourline, hypothetical) |
|---|---|---|
| 1. Summary | One paragraph: who you are, what you want built, the deadline for proposals | Freight forwarder seeking a partner to build a customer shipment-tracking portal and app; proposals due in 3 weeks |
| 2. Background | Your business, users, current systems and why this project exists now | Customers phone and email for shipment status; status queries take a large share of support time (internal estimate) |
| 3. Goals and success measures | Business outcomes with measurable targets, not features | Cut status calls by half within six months of launch; customers self-serve documents |
| 4. Users and key journeys | Who uses it and the three to five journeys that matter most | Shipper checks status, downloads proof of delivery, gets delay alerts; staff manage accounts |
| 5. Prioritised requirements | Must, Should, Could and Won't, kept short | See the prioritisation example in this guide |
| 6. Non-functional requirements | Security, accessibility, data protection, performance, hosting, support | OWASP ASVS-based security testing; WCAG 2.2 AA; data stays in existing cloud region |
| 7. Technical context | Existing systems, integrations, constraints, preferred or forbidden technologies | Must read from current transport management system via its API; single sign-on with existing customer accounts |
| 8. Budget and contract model | Budget range and proposed commercial structure | USD 120,000 to 160,000 for first release; fixed-price discovery then capped T&M build |
| 9. Timeline | RFP dates plus target launch window and any hard deadlines | Selection in 7 weeks; first release within 6 months of kickoff |
| 10. Ownership and legal terms | IP and code ownership, licences, data processing, confidentiality | Client owns all code and designs on payment; source in client's repository from day one |
| 11. What to send back | Required proposal structure, page limit, price format, references | Max 15 pages plus appendices; price split by discovery, milestones, rates and monthly support |
| 12. Evaluation and process | Criteria with weights, timeline, contact rules, Q&A process | Weighted scorecard published in the RFP; questions by a set date, answers shared with all vendors |
Sections 3, 5, 6 and 11 are where most RFPs go wrong, so the rest of this chapter covers them in detail.
Describe outcomes, not a full specification
Explain the problem and how you'll measure success, then let vendors propose the solution. The US government's digital procurement resource, TechFAR Hub's requirements guidance, recommends describing desired results "rather than instructions on what exactly to build", pairing high-level goals with quantitative metrics where relevant. Over-specifying features locks you into building them even after you learn they're the wrong ones.
This doesn't mean being vague. Name your users, their most important journeys and your measurable targets. If you have user research, include it; if you don't, ask vendors how they'd do it, because how a partner approaches UI/UX design and user research tells you a lot about whether they'll build the right thing.
Prioritise requirements so vendors price the same thing
An unprioritised list of 80 features produces 80-feature quotes. Use MoSCoW prioritisation: Must have, Should have, Could have and Won't have this time. The DSDM framework's MoSCoW guidance defines a Must as something without which you "cannot deliver a viable solution", and recommends keeping Must haves to typically no more than 60% of the effort, with around 20% of Could haves as contingency.

Prioritised requirements: Harbourline example (hypothetical)
| Priority | Requirement | Why it sits here |
|---|---|---|
| Must | Live shipment status pulled from the transport management system | The core reason the project exists |
| Must | Customer login with existing account credentials | Status data is customer-confidential |
| Must | Download proof of delivery and shipping documents | Second most common support request |
| Should | Email and push alerts for delays | High value, but customers can check manually at first |
| Should | Mobile app for iOS and Android | Most customers use desktop at work; web portal covers launch |
| Could | Carbon emissions estimate per shipment | Requested by some large customers; not critical to the goal |
| Won't (this release) | Online quoting and booking | Separate project with its own pricing rules |
State non-functional requirements by reference to real standards
Non-functional requirements describe how well the system must work rather than what it does, and they're where vague RFPs cause the most expensive surprises. Name standards instead of writing "must be secure", so every vendor prices the same level of work.
- Security: reference the OWASP Application Security Verification Standard, currently version 5.0.0, which was written partly to provide a basis for specifying security verification requirements in contracts. Ask vendors how they'll test against it and who reviews the results, ideally alongside your wider cloud security setup.
- Accessibility: name a conformance target such as WCAG 2.2 level AA, and ask how it will be tested, not just promised.
- Data protection: if the vendor will process personal data for you under GDPR, Article 28 requires a binding contract covering instructions, confidentiality, security, sub-processors, deletion or return of data, and audits. Ask vendors to confirm they'll sign one.
- Quality: say what testing you expect, including automated tests and who does user acceptance testing. A partner with a defined quality assurance process should be able to describe it in detail.
- Hosting and operations: where it runs, who owns the cloud accounts, uptime expectations, monitoring, backups and deployment. Ask how DevOps and release automation will be handed over at the end.
- Support: response times after launch, how long warranty fixes last, and the monthly cost of ongoing support.
Tell vendors exactly what to send back
This is the section that makes proposals comparable, so be strict. Set a page limit, a required section order, and a price format. If one vendor quotes a single number, another gives day rates and a third prices only the first phase, you can't compare them without going back to everyone.
- Understanding of the problem, in their own words, and any risks they see in your brief.
- Proposed approach: discovery, design, build, testing and launch, with milestones.
- Proposed solution outline and technology choices, with reasons and alternatives considered.
- Named team members, their roles and their time allocation, plus who you'll talk to day to day.
- Two or three comparable past projects, with references you can call.
- Price, split into discovery, each milestone, day or hourly rates by role, expected expenses and monthly support, with every assumption listed.
- Their standard contract terms on IP ownership, warranty and termination, flagged where they differ from yours.
Worked Example: Harbourline's RFP
To show how the pieces fit, this guide follows one hypothetical company. Harbourline is a fictional mid-sized freight forwarder, not an Apptechies client. Its customers phone and email the support team for shipment status, and the team estimates that status queries take up a large share of its day.
Harbourline's leadership decides to outsource the build because it has no in-house development team. Before writing, it agrees a budget range of USD 120,000 to 160,000 for the first release, chooses a fixed-price discovery followed by a capped time-and-materials build, and names its head of customer operations as decision owner with a four-person scoring panel.
Its RFP asks for a customer portal first, a web application that reads live data from the existing transport management system, with a native app as a Should have rather than a Must. That single choice keeps the first release affordable and makes the integration the main technical risk, so the RFP asks every vendor to explain how they'd approach API development and integration with a system they haven't seen. A vendor who proposes mobile app development for launch anyway would have to justify why.
Harbourline sends the RFP to five vendors chosen from referrals and research, using the shortlisting questions in our article on choosing a software development company. Its panel includes vendors in different regions, and weighs time-zone overlap as part of communication; our piece on offshore software development covers that trade-off.
Running the RFP Process: Timeline, Owners and Outputs
A well-run RFP takes about seven to nine weeks from internal approval to signed contract. The schedule below is an editorial suggestion, not a standard; compress it for small projects and extend it if procurement or legal review is slow in your organisation. Give vendors at least three weeks to respond, because good proposals take real work and rushed ones are mostly recycled text.
RFP process: phases, owners, outputs and acceptance conditions (suggested timeline)
| Phase and timing | Owner | Inputs | Output | Done when |
|---|---|---|---|---|
| Prepare (weeks 1 to 2) | Decision owner | Business case, budget approval | Budget range, contract model, panel, shortlist of 4 to 6 vendors | All three decisions signed off internally |
| Write (week 2) | Product owner with panel | Template, requirements workshop | RFP document and scorecard with weights | Panel agrees weights before issue |
| Issue and Q&A (week 3) | Single named contact | RFP, NDA if needed | Questions answered in writing and shared with all vendors | Question deadline passed; answers published |
| Responses (weeks 3 to 5) | Vendors | RFP and Q&A answers | Proposals in the required format | Deadline reached; late proposals handled per stated rule |
| Evaluate (weeks 6 to 7) | Scoring panel | Proposals, scorecard | Individual scores, then agreed shortlist of 2 to 3; technical sessions | Scores reconciled and recorded with reasons |
| Select and contract (weeks 8 to 9) | Decision owner, legal | Final scores, references | Signed contract or discovery agreement; feedback sent to all vendors | Contract signed; unsuccessful vendors told why |
Use one named contact for all vendor communication, and share every question and answer with all vendors at once. It keeps the process fair, and vendors notice when it isn't. If you'd rather have experienced help writing the RFP or running evaluation, independent software development consulting can do this without being one of the bidders.
How to Evaluate Proposals Fairly
Score every proposal against the same weighted criteria, set before you read any of them. Each panel member scores alone first, on a 1 to 5 scale, and then the panel meets to discuss large differences. Averaging silently hides disagreements that usually point to a real question for the vendor.
The weighted vendor scorecard
Weights should reflect what matters for your project and must add up to 100. The weighted score for each vendor is the sum of each weight multiplied by its 1 to 5 score, divided by 5, giving a result out of 100. The filled example shows Harbourline's panel scores for three anonymised vendors after the technical sessions.
Weighted vendor scorecard: Harbourline example (hypothetical scores, 1 to 5)
| Criterion | Weight | Vendor A | Vendor B | Vendor C |
|---|---|---|---|---|
| Understanding of the problem and approach | 25 | 4 | 3 | 5 |
| Relevant evidence: similar projects, references | 20 | 3 | 5 | 4 |
| Team and delivery process | 15 | 4 | 3 | 4 |
| Technical quality: architecture, security, testing | 15 | 4 | 3 | 5 |
| Price and commercial terms | 15 | 3 | 5 | 2 |
| Communication and post-launch support | 10 | 4 | 3 | 4 |
| Weighted score (out of 100) | 100 | 73.0 | 74.0 | 82.0 |

Vendor C wins on the agreed weights even though it's the most expensive, because it scored best on understanding and technical quality. Now see why the weights must be fixed first. If the panel had weighted price at 30% and understanding at 10%, Vendor B would score 80.0, Vendor C 73.0 and Vendor A 70.0, and B would win. Neither answer is wrong, but choosing weights after seeing the prices lets you justify any decision you'd already leaned towards.
Check price before you trust the score
Treat the budget range as a gate as well as a score. A proposal outside your approved range should be clarified or set aside before scoring, not quietly marked down on price. Also compare price assumptions line by line: a low quote often excludes testing, project management or post-launch fixes that another vendor included.
Run a short technical session with the shortlist
Written proposals show how well a vendor writes. A two-hour session with the people who'd actually build your software shows how well they think. TechFAR Hub's technical evaluation guidance suggests oral presentations, reviewing samples of an offeror's past code and its results, and technical challenges, with presentations "tightly controlled and recorded" so every vendor is treated equally.
- Ask the proposed team, not only sales staff, to walk through how they'd tackle your riskiest requirement.
- Give every vendor the same scenario, such as an integration failing in production, and ask what happens next.
- Ask to see a real repository, test suite or deployment pipeline from a past project, with client permission.
- Ask what they'd cut first if the budget dropped by a quarter. Good partners answer quickly and honestly.
Red flags in proposals
- No questions during the Q&A window and no risks named in the proposal. Either they didn't read the brief closely or they're avoiding difficult points.
- A fixed price with no assumptions listed. Every fixed price rests on assumptions; hidden ones become change requests later.
- The team in the proposal isn't the team in the meeting, or names are missing entirely.
- Code, designs or cloud accounts that stay in the vendor's name until some future handover date.
- References that are all more than a few years old, or that the vendor can't put you in touch with.
Our checklist of what to consider before hiring an app development company has more questions for reference calls.
After You Choose: From RFP to Contract and Kickoff
The winning proposal becomes the starting point for the contract, not the contract itself. Turn it into a statement of work that lists the deliverables, milestones, acceptance criteria for each milestone, the named team, the price structure and the change process. Attach your RFP and the vendor's proposal as schedules, so promises made during selection stay enforceable.
- Confirm ownership: code in your repository, cloud accounts in your name, designs and documentation delivered as work progresses.
- Agree acceptance criteria for each milestone, including who tests and how many days they have to accept or reject.
- Sign the data processing agreement if personal data is involved.
- Plan the first two to four weeks as discovery or onboarding, with a clear output: refined backlog, architecture outline and an updated plan.
- Agree what happens after launch: warranty period, support hours and the monthly cost of keeping the system running.
Tell unsuccessful vendors the outcome promptly and give each a short reason. It costs you little, and you may want to work with them on a later project. A good partner will also show you how they'll run the engagement from week one; this is how our delivery process works, as one example of what to ask for.
Your Next Step
Start with the three decisions: budget range, contract model and decision owner. Then copy the twelve-section template above, fill in the Harbourline column with your own project, and set your scorecard weights before you send anything. That alone puts your RFP ahead of most that vendors receive.
If you're preparing an RFP for custom software development and want a second opinion on scope, priorities or budget before you send it, a partner experienced in software development outsourcing can review it with you.
