ERP Requirements Document: Write One Vendors Can’t Misread
In this article
- What an ERP requirements document is, and what it is not
- Start from processes, not feature lists
- How to write a testable requirement
- Prioritize with MoSCoW and cap the Must list
- A section-by-section template
- Non-functional and local requirements people forget
- From requirements to RFP: the response and scoring sheet
- Mistakes that cost you after signature
- Key takeaways
- Frequently asked questions
- What should an ERP requirements document include?
- How long should an ERP requirements document be?
- What is the difference between a BRD and an RFP for ERP?
- How do I prioritize ERP requirements?
- Who should write the ERP requirements document?
An ERP requirements document is the file that tells vendors what your business needs the system to do, written so that each statement can be tested at acceptance. Done well, it is the backbone of the RFP, the guide for configuration, and the checklist for user acceptance testing. Done loosely, it becomes the vendor’s strongest argument in every change-request dispute after the contract is signed.
I learned how much the wording matters when I audited a delivered manufacturing execution system (MES) against its signed requirements specification. I built a 60-point test plan directly from that document and ran it over four test cycles. It surfaced 3 defects and about 20 functional gaps, and the only reason those gaps counted as gaps rather than “differences of interpretation” was that the requirements were specific enough to test. That evidence became the basis for a controlled partial acceptance instead of an argument. Everything below is written to get you that kind of document before you ask anyone for a proposal.
What an ERP requirements document is, and what it is not
The requirements document describes what the business needs, by process, in measurable terms. It is not a list of modules copied from a vendor brochure, and it is not a technical design. Three documents get confused: the business requirements document (BRD), which the company writes and which later serves as RFP core, contract annex and UAT baseline; the RFP, which wraps the BRD with commercial terms, response rules and evaluation criteria; and the functional specification, which the chosen vendor writes to show how the product meets each requirement, and which should trace back to your requirement IDs line by line.
The BRD is the part you own completely. If you are still deciding which product family fits, the comparison in SAP Business One vs Odoo for Saudi companies is a reasonable starting point, but write the requirements before you fall in love with a product.
Start from processes, not feature lists
The most common failure I see is a requirements document organized by module: “Finance: general ledger, AP, AR, fixed assets…”. Every ERP has those. A module list cannot distinguish between vendors and cannot be tested. Organize the document by end-to-end business process instead: order to cash, procure to pay, plan to produce, hire to retire, record to report. Inside each process, describe the current state (as-is), the target state (to-be), and then the requirements that get you from one to the other.
A short as-is/to-be pair for each process is enough. For example, imagine a distributor whose sales team takes orders on WhatsApp and re-keys them into an accounting system:
- As-is: Orders arrive by phone and chat; a coordinator types them into the accounting system; stock is checked by calling the warehouse; about one order in ten is corrected after dispatch.
- To-be: Sales staff enter orders against live stock with a credit check at entry; the warehouse receives a pick list automatically; invoice follows delivery confirmation without re-keying.
Once the to-be is written, the requirements almost write themselves: credit check at order entry, available-to-promise visibility, automatic pick list, delivery-to-invoice flow. Vendors can now show you exactly those steps in a demo instead of a generic tour.
How to write a testable requirement
A requirement is testable when two people can independently read it, perform a test, and agree on pass or fail. The practical formula I use has six parts: actor, trigger, action, data, outcome, acceptance criterion. Compare the two versions below.
Weak: "The system should support credit control."
Testable:
ID: OTC-014
Process: Order to cash
Priority: Must
Statement: When a sales user saves a sales order, the system shall
compare the customer's open balance plus the new order
value against the credit limit held on the customer master.
If the limit is exceeded, the order is saved in a blocked
status and cannot be delivered until a user with the
"credit release" authorization releases it.
Acceptance: Create a customer with limit 10,000; post an open
invoice of 8,000; enter an order of 3,000. Expected: order
blocked, delivery not possible, release by authorized
user unblocks it, audit trail shows who released it.
Rules that keep wording testable:
- Use “shall” for obligations. Avoid “support”, “handle”, “manage”, “user-friendly” and “flexible”; none of them can fail a test.
- Name the data: which field, which master record, which document.
- State the negative case: what happens when the condition is not met.
- Give each requirement a unique ID that will survive into the contract, the functional specification and the UAT plan.
- One requirement per statement. “The system shall print and email the invoice” is two requirements with two different ways to fail.
- Put a measurable acceptance criterion next to every Must requirement.
Prioritize with MoSCoW and cap the Must list
MoSCoW (Must, Should, Could, Won’t) is simple enough that process owners actually use it, which is why I prefer it over numeric weightings at this stage. The trap is that every owner marks everything as Must. Two rules fix that:
- Must means “we would not go live without it”. If the business could run for a quarter with a workaround, it is a Should.
- Cap Must at roughly a third of the list. If a department exceeds the cap, the owner has to trade. This forces the conversation that would otherwise happen during a budget overrun.
Mark the “Won’t (this phase)” items explicitly. A written Won’t list protects you from scope creep and tells vendors not to price features you are deferring.
A section-by-section template
This is the structure I use for mid-sized companies. Adjust the process list to your business, but keep the order: context first, requirements in the middle, response rules at the end.
- Company and project context: what the company does, sites, legal entities, users by role, transaction volumes (orders per day, invoices per month, SKUs, employees), current systems and their fate (replace, keep, integrate).
- Objectives and success measures: three to five measurable outcomes, such as month-end close in five working days, or zero manual re-entry between production and finance.
- Scope: processes in and out, entities in and out, phases if any.
- Process requirements: one section per end-to-end process, each with as-is, to-be, and a numbered requirement table (ID, statement, priority, acceptance criterion, vendor response column).
- Reporting and analytics requirements: the specific reports and dashboards management needs, with the fields and grouping each requires, not “flexible reporting”.
- Integration requirements: every system that exchanges data with the ERP, the direction, the frequency, the owner of the interface and the behavior on failure.
- Data migration requirements: which objects migrate, how much history, who cleanses, who loads, and the reconciliation sign-off you expect.
- Non-functional and local requirements: see the next section.
- Implementation requirements: methodology, team roles, training by role, UAT cycles, hypercare period, documentation deliverables.
- Commercial and contractual requirements: licensing model, support SLAs, change-request rates, intellectual property of customizations, exit and data-return clauses.
- Response instructions and evaluation criteria: how to fill the response column, demo script, timeline, scoring weights.
Non-functional and local requirements people forget
Functional requirements get the attention; non-functional ones cause the surprises. For a company operating in Saudi Arabia, I make sure the document covers at least the following, each written as a testable statement rather than a heading:
- Language and interface: Arabic and English user interface where needed, bilingual document layouts (invoices, purchase orders), right-to-left printing.
- E-invoicing: compliance with the ZATCA e-invoicing requirements applicable to your business, including who is responsible for keeping the solution compliant as regulations change. The specifics are covered in what ZATCA Phase 2 integration involves for an ERP.
- Payroll and HR interfaces: if payroll lives in a separate HR system, state the direction and frequency of the exchange (employee master, cost centers, payroll journal).
- Security, access and data protection: role-based authorizations, segregation of duties for critical pairs (create vendor and approve payment), audit trail on master data changes, where data is hosted and how personal data is protected in line with the Saudi Personal Data Protection Law.
- Performance and availability: expected concurrent users, acceptable posting times for your heaviest transactions, maintenance windows, uptime commitment.
- Integration with shop-floor systems: for manufacturers, the exchange with MES, formulation or weighing systems. How SAP Business One, an MES and an HR system were connected in one plant is described in this SAP Business One manufacturing case study.
From requirements to RFP: the response and scoring sheet
The requirement table needs a vendor response column with fixed answer codes. Free-text answers cannot be compared. The codes I use:
| Code | Meaning | Score | What you ask next |
|---|---|---|---|
| S | Standard: met out of the box | 3 | Show it in the scripted demo |
| C | Configuration: met by settings, no code | 2 | Who configures it, and is it in the estimate? |
| D | Development: met by customization or add-on code | 1 | Effort in days, who owns the code, upgrade impact |
| T | Third party: met by another product | 1 | Name the product, licensing, who supports the interface |
| N | Not available | 0 | Workaround proposed? Roadmap commitment in writing? |
Weight the scores by priority (for example Must x3, Should x2, Could x1) and compute a functional fit percentage per vendor. Then apply the decision rule I recommend to clients: any Must requirement answered N or D by a vendor is reviewed in person before the scores are compared, because a single missing Must can outweigh a 10-point lead elsewhere. Keep the functional score separate from the commercial score; merge them only at the end, with weights agreed before proposals arrive. Make every vendor demonstrate the Must requirements using your scenarios and, ideally, a sample of your data, and record the demo against the requirement IDs.
Mistakes that cost you after signature
- Letting the vendor write the requirements. A vendor-authored document describes the product, not your business. Use outside help if you need it, but keep authorship on your side; this is exactly what a business analysis engagement is for.
- No requirement IDs. Without IDs, nothing in the contract, the design or the UAT plan traces back to what you asked for.
- Skipping volumes. Without transaction counts and user numbers, vendors size the project on assumptions, and the assumptions resurface as change requests.
- Ignoring reports and interfaces until build. Management reports are where executives judge the project, and every undocumented interface becomes someone else’s problem, usually yours.
- Not attaching the document to the contract. The requirements document, with the vendor’s response codes, should be a contract annex. Otherwise the proposal’s marketing text governs.
Key takeaways
- Organize by end-to-end process with as-is and to-be, not by module.
- Write each requirement with an actor, trigger, action, data, outcome and acceptance criterion, and give it an ID.
- Use MoSCoW and cap Must at about a third of the list.
- Force fixed response codes (S/C/D/T/N) and score functional fit separately from price.
- Cover language, e-invoicing, HR interfaces, security, data residency and shop-floor integration as testable requirements.
- Attach the document and the vendor’s responses to the contract; reuse the IDs in the UAT plan.
Frequently asked questions
What should an ERP requirements document include?
Company context and volumes, measurable objectives, scope, process-by-process requirements with IDs and priorities, reporting and integration requirements, data migration expectations, non-functional requirements (security, language, compliance, performance), implementation expectations such as training and UAT, and commercial terms. Each functional requirement needs an acceptance criterion so it can be tested after delivery.
How long should an ERP requirements document be?
Long enough to cover every process that will change, and no longer. For a mid-sized company, 150 to 400 numbered requirements is typical. Length is less important than precision: a 60-page document of untestable statements is worth less than 20 pages of requirements that each have an ID, a priority and a pass/fail criterion.
What is the difference between a BRD and an RFP for ERP?
The business requirements document (BRD) describes what the business needs the system to do and why. The request for proposal (RFP) packages the BRD with commercial terms, response instructions, timeline and evaluation criteria so vendors can bid. The BRD is the core; the RFP is the procurement wrapper around it.
How do I prioritize ERP requirements?
Use MoSCoW: Must (cannot go live without), Should (important, workaround possible for a limited time), Could (nice to have), Won’t (deferred). Cap the Must category, typically at about a third of all requirements, so that owners trade rather than inflate. Weight scores by priority when comparing vendor responses.
Who should write the ERP requirements document?
The company, led by a business analyst or project manager working with each process owner. Vendors can clarify questions but should not author it, because the document later governs scope, acceptance and change requests. An independent consultant can facilitate workshops and write the document while ownership stays with the business.
If you are preparing an ERP selection and want the requirements written and scored from the company’s side, I offer this as part of my business analysis service, and it feeds directly into the wider client-side ERP implementation process. You can get in touch here to discuss where your project stands.