How to Write ERP Requirements Vendors Can’t Game (2026 Guide for Cities and Counties)
Learn how to write ERP requirements vendors can't game in 2026: scenario-based requirements, strict response codes, scripted demos and scoring for governments.
On this page
- Key takeaways
- How to write ERP requirements vendors can’t game (quick answer)
- What are ERP requirements (and why a yes/no ERP requirements checklist gets gamed)?
- Step 1: Start from processes and outcomes, not your legacy system
- Step 2: Rewrite critical requirements as scenarios, not features
- Step 3: Keep yes/no lines for true pass/fail gates
- Step 4: Define ERP RFP response codes that close the loopholes
- Step 5: Turn scenarios into a scripted ERP demo and verify every claim
- Step 6: Score ERP RFP responses so demonstrated fit wins
- Step 7: Make the response matrix part of the contract
- Common mistakes when writing ERP requirements in 2026
- FAQ
- Write requirements a vendor has to prove
How to write ERP requirements vendors can’t game comes down to format: write your critical requirements as end-to-end scenarios instead of yes/no features. Force every answer into a strict response code (standard, configuration, customization, third-party, future or not available), then demand proof in a scripted demo, score what vendors show over what they claim, and carry every answer into the contract. Do those five things and a vague “yes” stops earning points.
Key takeaways
Write your top requirements as scenarios with a start, an end, named actors and a visible outcome.
Define response codes up front, and make “configurable” and “third-party” mean something specific.
Treat “future release” and partial answers as not met (KCT rule of thumb).
Verify claims in a scripted demo built from the same requirement IDs.
Score demonstrated functionality, and price every customization and third-party product into total cost.
Attach the response matrix to the contract so the answers stay binding.
A requirement like “supports grant management” gets a yes from every vendor in the room. That yes tells you nothing about whether your grants team can close a reimbursement request on day one.
Volume doesn’t fix it either. When the Idaho State Controller’s Office shopped for its Luma system in 2018, evaluators got just three weeks to analyze and score more than 2,500 pages of technical documents on top of their regular duties. The state’s Office of Performance Evaluations concluded they likely couldn’t read the proposals in full (as reported by Boise State Public Radio, November 8, 2024).
KCT advises cities, counties and districts on ERP selection and also implements ERPs, so our team sees what happens when a written “yes” meets go-live. If you’re still deciding what kind of system you need, start with our guide to choosing an ERP system for the public sector. This guide picks up once you’re writing the RFP.
Below are seven steps for a government ERP RFP, with real city RFP examples from 2023 to 2026 (Raleigh, Fargo and Sammamish) you can borrow from.
How to write ERP requirements vendors can’t game (quick answer)
To write ERP requirements vendors can’t game, start from your processes, rewrite critical needs as scenario-based requirements with actors and proof points, and keep yes/no lines for pass/fail gates. Then define strict response codes, verify every claim in a scripted demo, score demonstrated fit, and make the response matrix part of the contract.
Start from processes and outcomes, not your legacy screens.
Rewrite your critical requirements as scenarios with actors, a start, an end and proof points.
Keep yes/no lines only for true pass/fail gates.
Define strict response codes and require evidence with every answer.
Turn your scenarios into a scripted demo and score them live.
Weight scoring toward demonstrated fit and price every gap.
Make the response matrix part of the contract.
What are ERP requirements (and why a yes/no ERP requirements checklist gets gamed)?
ERP requirements are the documented business, functional and technical capabilities a government needs from a new ERP system, written so vendors can respond and evaluators can score consistently. Functional requirements describe what the system does. Non-functional requirements cover how it does it: security, performance, integration and usability.
The trouble starts with format. A long spreadsheet of one-line features invites one-word answers, and one-word answers are easy to stretch.
These are the patterns our team sees most often in vendor responses:
Good RFPs are already pushing back. The City of Raleigh’s 2026 ERP RFP says responses will be evaluated in light of the “material and substantiating evidence presented in the response and not based on what is inferred”. In plain terms, a bare yes won’t score.
Your move: open your current draft and highlight every line any modern ERP would answer “yes”. Those highlighted lines are your rewrite list.
Step 1: Start from processes and outcomes, not your legacy system
Requirements copied from your current system’s screens lock in old workarounds and push vendors toward customization. Write down the outcome you need instead, and let vendors show how their standard product gets there.
Microsoft’s own Dynamics 365 implementation guide makes the same point from the vendor side. Its fit-to-standard and fit-gap guidance says this approach “reduces customizations by delivering your business needs through configuration rather than creating detailed requirements that might be based on your legacy system,” and recommends a culture of “adopt wherever possible, adapt only where justified.”
Cities are writing the same intent into their RFPs:
The City of Sammamish, WA (2024) wanted a solution that would meet its core requirements “out of the box with minimal modifications” and “remain on the upgrade path with minimal cost and business impact.”
Raleigh (2026), which has run PeopleSoft since 2007 in a heavily configured state, lists “minimizing customizations, third-party applications, and system complexity” as a technical driver.
Your move: organize requirements by end-to-end process, such as procure to pay, hire to retire, budget to actuals, record to report and meter to cash. Tag each requirement with the policy, ordinance or statute behind it. A requirement with no rule behind it is often a habit, and habits are where customizations come from.
Step 2: Rewrite critical requirements as scenarios, not features
A scenario requirement, sometimes called a use case requirement, describes a real transaction from start to finish, names who does it, and says what proof you need to see. Vendors can’t answer it with a single word, and that’s the point.
Raleigh’s 2026 RFP is a strong public model. Its demonstration appendix asks vendors to showcase “key use cases that reflect real-world scenarios relevant to municipal operations”. Each use case lists:
a business outcome
the main actor(s)
a scenario beginning and a scenario end
key requirements framed as “demonstrate the system’s ability to” do specific tasks
Take its “Manage Grants” use case. It begins when a grant request arrives and ends with the request processed and grants awarded. In between, vendors must show grant tracking from setup through completion, reimbursement requests and receivables, workflow approvals, and attributes like grant type, owner, amount and agency.
Compare that with a single checklist line. Here’s the rewrite across common public-sector areas (KCT-written examples):
Swipe to see all columns →
| Area | Yes/no checklist line | Scenario requirement |
|---|---|---|
| Grants | Supports grant management | Create a grant-funded PO, encumber it against the grant budget, receive and pay the invoice, and show the encumbrance release and the draw on the grant reimbursement report. |
| Encumbrances and year-end | Supports encumbrance accounting | Roll an open PO encumbrance into the new fiscal year and show budget availability in both years. |
| Utility billing | Integrates with meter reading | Import a meter read file, store consumption to the single gallon, calculate a tiered bill, and export the same precision to the customer portal. |
| Payroll | Handles retro pay | Process a retroactive raise across two pay periods for a union employee and show the GL and position budget impact. |
| Procurement | Has approval workflow | Route a $60,000 requisition through department, finance and council-threshold approvals while the usual approver is out of office and a delegate approves. |
Each scenario in the right column names data, steps and an output you can check on screen. A vendor either shows it or doesn’t.
That detail matters after selection too. The City of Farmers Branch, TX needed single-gallon, resident-facing water-usage visibility, and KCT’s findings report pinpointed where precision was lost: storage, calculation or export mapping.
“Integrates with meter reading” would never surface that gap. A scenario that says “store, calculate and export to the single gallon” would.
Your move: write 20 to 40 scenarios for your highest-risk processes (KCT rule of thumb), give each one a requirement ID, and keep shorter line items for everything else. No single standard sets the right number, so prioritize instead of padding.
Step 3: Keep yes/no lines for true pass/fail gates
Binary lines still have a job. Use them for non-negotiables, where a single “no” knocks a vendor out.
Our guide on how to shortlist ERP vendors for a city or county covers knockout gates in detail. For requirements writing, what matters is keeping the two layers separate.
The City of Fargo, ND’s 2023 RFP shows the split working. It scored written responses to its functional and technical requirements at the shortlist stage, then scored demonstrated functionality separately for finalists. Written claims got a vendor into the room, and proof decided the rest.
Your move: rank every requirement as must-have, important or nice-to-have, and make only must-haves into gates. Keep the gate list to a page, not a spreadsheet (KCT rule of thumb). If everything is a gate, nothing is.
Step 4: Define ERP RFP response codes that close the loopholes
The response code is where most gaming happens. Define each code in the RFP itself and tell vendors exactly how each one will be scored and priced. Undefined codes let vendors pick the most flattering word.
Here’s the scheme KCT recommends (KCT rule of thumb, adapt it to your procurement rules):
Swipe to see all columns →
| Code | What it must mean | What the vendor must provide | How KCT suggests treating it |
|---|---|---|---|
| S: Standard | Delivered in the proposed version with no setup beyond normal parameters | Release or version number, and where it appears in documentation | Full credit, must be demoed |
| C: Configuration | Met with vendor-supported settings, workflows or report builders, no code, survives upgrades | What gets configured, who does it, and confirmation it’s in the implementation price | Full or near-full credit |
| X: Customization | Needs code, scripts, custom reports or extensions | Itemized hours and cost, plus upgrade impact | Partial credit, cost added to total cost of ownership |
| T: Third-party | Met by another company’s product | Product name, vendor, licensing, integration method and who supports it | Partial credit, licensing in total cost, integration in the SOW |
| F: Future release | Not generally available today | Committed release date | Scored as not met |
| N: Not available | Can’t be met | Any workaround | Zero |
These categories aren’t invented from scratch. Microsoft’s implementation guide separates standard and configured processes from gaps filled “with customizations or extensions,” and names buying a partner or third-party solution as another option. It also advises judging a customization’s impact on connected processes, not just the one you’re changing.
Codes follow you past award, too. The GFOA ERP Readiness Checklist says that if modifications were identified in the vendor’s response to the functional requirements, the government “will want to decide if they are still included in scope.” The X answers you accept now become implementation scope later.
And keep the version honest. Fargo required that “the proposed version of the software must be shown” and that it “must not include any software that is under development or in beta testing.”
Add these rules to your RFP instructions (KCT rule of thumb):
One code per requirement. No “yes, partially.”
A comment is required for every C, X or T answer.
Any answer not demonstrated when asked may be rescored.
The final responses become a contract exhibit.
Your move: paste the code definitions into both the RFP instructions and the header of the response matrix, so no one can say they missed them.
Many requirement sets our team reviews are inherited from the last RFP or a vendor template, and they invite blanket yeses. KCT’s ERP Consulting & Selection Advisory reviews or rewrites requirements, response codes and scoring before the RFP goes out, from a vendor-neutral seat. KCT is not a Tyler partner or reseller and takes no referral fees from Tyler.
Step 5: Turn scenarios into a scripted ERP demo and verify every claim
A written answer is a claim. A scripted demo is the evidence. Build the demo script from the same requirement IDs you used in the RFP, so you can trace every response code to what you actually saw.
The public examples are clear on this:
Raleigh (2026) flagged initial use cases in the RFP for the demo, provides a detailed agenda 7 days before each two-day demonstration, and requires demos to be “based solely upon information provided in each Vendor’s original proposal.” No new information may be presented.
Fargo (2023) told vendors “the provided scripts must be strictly adhered to while presenting”, and optional modules outside the requested scope couldn’t be shown.
Sammamish (2024) reserved the right to require a scripted product demonstration from finalists, and stated plainly that it was “not interested in unnecessary sales verbiage.”
Raleigh’s “no new information” rule does a lot of work. If a vendor coded something S in writing, the demo must show it. If they can only show it with a new add-on, that’s a T, and it gets rescored.
During the demo, have evaluators do four things:
Mark each scenario as shown, partially shown or not shown.
Ask on screen: “Is this configuration or a custom build?”
Ask which release you’re looking at.
Note anything shown that the written response coded differently.
For demo logistics (timing, using your own data, who should attend), see our guide on shortlisting ERP vendors.
Your move: keep a verification log with four columns: requirement ID, written code, demo result and evaluator note. Rescore any written answer the demo didn’t support.
Step 6: Score ERP RFP responses so demonstrated fit wins
Strong ERP RFP evaluation criteria score in stages, lock the weights before proposals arrive, and give real points to what vendors demonstrate, not to adjectives in the proposal.
Here’s how three recent city RFPs weighted requirement fit, demos and cost (figures from each RFP):
Swipe to see all columns →
| Agency | Year | Requirement fit | Demo | Cost |
|---|---|---|---|---|
| Fargo, ND | 2023 | 35 points for written functionality at shortlist | 15 points for demonstrated functionality at finals | 40 points, possibly on a fully loaded ten-year cost of ownership |
| Raleigh, NC | 2026 | 450 of 1,000 points across Finance (125), HCM (125), Payroll and Time (50), Budget (25), Inventory (25) and Nonfunctional (100) | Separate Stage 2 demonstration of flagged use cases | 150 of 1,000 points, based on total cost of ownership |
| Sammamish, WA | 2024 | 50 of 103 points for thoroughness, content quality and responsiveness to RFP requirements | Scripted demo reserved for finalists | 20 of 103 points |
The point scales differ, so compare the structure, not the numbers. In each case, requirement fit carries a large share of the score, so the requirements need to be specific enough to score honestly.
Now connect scoring to your response codes. A simple model works (KCT rule of thumb): S and C earn full credit, X and T earn partial credit, F and N earn zero.
Then add the cost of every X and T item into total cost of ownership. Otherwise a low bid with 40 customizations looks like the cheapest option when it isn’t.
Your move: have evaluators sign off on weights and code-point values before anyone opens a proposal. Score independently first, then meet to reconcile.
Step 7: Make the response matrix part of the contract
If the answers aren’t in the contract, the vendor isn’t bound to them. The response matrix, adjusted after demos, should travel straight into the agreement.
Public audits show what happens when specifics are missing. Idaho’s performance evaluators found the implementer’s goals for Luma were “highly generic” and based on templates, and that the lack of specificity in the contract and early project documents kept the state from having clear criteria to reject deliverables (Boise State Public Radio, November 2024).
In the UK, Birmingham City Council’s external auditors found its Oracle solution design “was not fully resolved” when it went live in 2022. A project budgeted at £19 million in 2019 may now cost as much as £130 million (The Register, January 2025).
A follow-up report described the council waiting on third-party software it hoped would fix its bank reconciliation and cash management problems (The Register, February 2025). Third-party pieces are real scope, so name them early.
The GFOA ERP Readiness Checklist also tells governments to validate the functional requirements that define each interface and to confirm workflows from the requirements are still in scope. That’s much easier when the requirements are scenarios with IDs, because requirements traceability runs from the RFP to the demo to the contract.
Before signature, do three things:
Attach the final, demo-adjusted response matrix as a contract exhibit.
Tie acceptance testing to the same scenario scripts.
List every X and T item in the implementation statement of work with a price and an owner.
For the cost side of that review, see our guide to hidden costs in an ERP vendor contract.
Your move: reconcile the response matrix, the demo log and the SOW line by line before anyone signs. Every mismatch is a conversation you want to have now, not after go-live.
Common mistakes when writing ERP requirements in 2026
Most requirement problems come from a handful of habits. Here’s each one with its fix:
FAQ
What are ERP requirements?
ERP requirements are the documented business, functional and technical capabilities a government needs from a new ERP system. Functional requirements describe what the system must do, like encumbering a PO, while non-functional requirements cover security, performance and integration. Good requirements are written so every vendor answer can be scored and verified.
How do you write requirements for an ERP RFP?
Writing requirements for an ERP RFP starts with your end-to-end processes, not your current system. Write critical requirements as scenarios with actors, a start, an end and proof points. Keep yes/no lines for pass/fail gates, define strict response codes, and verify answers in a scripted demo built from the same requirement IDs.
How many requirements should an ERP RFP have?
No single standard sets how many requirements an ERP RFP should have, and quality beats count. As a KCT rule of thumb, write 20 to 40 detailed scenarios for your highest-risk processes, keep a short list of pass/fail gates, and use brief line items for lower-risk needs, so evaluators can actually read and score everything.
How do you score ERP RFP responses?
ERP RFP responses are best scored in stages, with weights locked before proposals open. Score written answers first, then demonstrated functionality in scripted demos, as Fargo’s 2023 RFP did at the shortlist and finalist stages. Add every customization and third-party cost into total cost of ownership.
What is the difference between configuration and customization in ERP?
Configuration in ERP means meeting a need with vendor-supported settings, workflows or report tools, without writing code. Customization means adding code, scripts or extensions to change how the product works. Microsoft’s implementation guidance favors configuration and advises weighing a customization’s impact on connected processes, which is why customization usually costs more to build, test and upgrade.
What is a scripted ERP demo?
A scripted ERP demo is a vendor demonstration that follows scenarios the buyer writes, instead of the vendor’s standard sales demo. Fargo required vendors to strictly follow its scripts, and Raleigh’s 2026 RFP limits demos to what was in the original proposal. Scripts let evaluators compare vendors on the same tasks.
Write requirements a vendor has to prove
The goal isn’t more requirements. It’s requirements where every answer is specific, provable and binding, from the RFP to the demo to the contract.
Before your RFP goes out, pick your ten riskiest processes and rewrite them as scenarios with IDs and clear proof points. That one change shifts the answers you get back, because vendors can no longer win points with a single word.
If you want help, KCT’s ERP Consulting & Selection Advisory can review or build your requirements, response codes, demo scripts and scoring model. Because KCT also implements ERPs, we write requirements with go-live in mind.
The right level of support depends on your modules, departments and stakeholders, so most agencies start with an assessment, and our team can step in at any point. Talk to our team before your RFP goes out.