“I’ve read the contract. Nothing wrong with it. Let’s just sign it as is.”
I’ve heard this line too many times. The contract in the owner’s hand is usually a dozen-plus pages. The first few pages carry both companies’ names, the name of what’s being purchased, the total price, and the payment installments. The rest is a pile of clauses that look like boilerplate. What the owner actually reads is often just two numbers: the total amount and the go-live date.
The problem is, those two numbers are the part of the contract least likely to go wrong. The amount is in black and white. Both sides remember the go-live date. What keeps you up at night three months, six months, two years later are the places the contract “doesn’t say” or “says vaguely.”
And nobody will point these out to you. Not because the vendor is bad, but because nobody is obligated to think through your risks for you. The salesperson’s job is to close the deal. The consultant’s job is to finish the project. Legal’s job is to protect their own company. Along the whole chain, not one person has a KPI that says “get this owner a contract that works in his favor.”
I’m Johnny Yang, Brightstream Technology, Taiwan. I’ve led teams doing implementation for seven years, across 252+ projects in 32+ industries. The thing I’ve done most in these years isn’t helping owners pick a system. It’s getting called in the day before they sign to take one look at the contract. My method is always the same: I don’t read the legal text clause by clause. I take a sheet of paper, write down 12 questions, and go through the contract looking for each answer. Found it, check mark. Can’t find it, circle it. The circled questions are where this project will have fights later.
This article is that sheet of paper.
The conclusion up front: the risk in an ERP contract isn’t clauses written wrong. It’s clauses not written. The 12 questions you need to ask fall into four groups — money, people, delivery, exit. Everyone asks the money questions, but usually only about unit price, not scope. Almost nobody asks the people questions, yet half of a project’s success sits there. The delivery questions decide when you pay the final installment and when the warranty starts. The exit questions are the most awkward and the least asked, but they are the only group where “if you don’t ask before signing, you will never get to ask.” Ask all 12 and your contract won’t necessarily get cheaper, but it will get clear — and clear is what you actually need from this deal.
Why what the contract leaves out is more dangerous than what it gets wrong
One idea first. Once you get this, you’ll know what you’re really asking in the 12 questions that follow.
ERP is an unusual purchase. When you buy a machine, the spec sheet spells it out: dimensions, capacity, power draw, precision. Acceptance means measuring against the spec. With ERP, what you’re buying is a working relationship that hasn’t happened yet. The system exists, but how it’s configured, whether it gets modified, how the data moves over, how processes adapt, who has to learn it, and what happens if they can’t — none of that exists yet on the day you sign.
So an ERP contract isn’t really a “sales contract.” It’s closer to “a contract for work plus a long-term service relationship.” What this kind of contract fears most isn’t a clause written wrong. It’s both sides reading the same sentence differently.
The most common example: the contract says “three months of warranty after the system goes live.” Looks clear, right? But which day is “go-live”? The day someone first creates an order in the system? The day every module has switched over? The day you sign the acceptance form? Or the day the vendor unilaterally announces “the system is live”?
Those four dates can be three months apart. And if the contract doesn’t define it, which one gets used depends on whose position is stronger. Before signing, your position is strongest. After you’ve paid, it’s weakest. That’s why every question has to be asked before you sign.
One more thing to accept up front: you will not find these by “reading the contract.” The vendor drafted it. He won’t write a clause against himself. Your job is to ask, get the answers in, and lock them down in a supplementary clause, an appendix, or at minimum meeting minutes signed by both sides.
Right. On to the questions.
Group one: money — ask about scope, not just unit price
Every owner asks about money, but nine out of ten ask in the wrong direction. Everyone asks “can you go a bit lower.” Very few ask “how far does this price actually go.”
Haggling gets you a few percentage points, once. Unclear scope gets you add-ons with no ceiling. These are not the same order of magnitude.
Question 1: Does this quotation include these items?
Why ask. A quotation lists what’s in. It doesn’t list what’s out. And in an ERP implementation, the items that most often turn into extra charges are the ones the owner assumed were included.
Read them out one by one and ask “is this included” for each. At minimum: data migration (moving historical data from the old system or Excel), training (how many sessions, how many hours, at your office or theirs, and whether retraining after staff turnover counts), custom reports (the reports you use today — if the system can’t produce them, who builds them), integration with existing systems (e-invoicing, payments, e-commerce platforms, logistics), hardware and operating system (if on-premise), on-site support on go-live day, and server environment setup and backup.
What a good answer looks like. The vendor answers item by item on the spot — “this is in, this is out, the out part is roughly this many person-days extra” — and is willing to put the included items in a contract appendix, even with quantities: how many training sessions, how many tables migrated, how many custom reports. A commitment with a quantity is a commitment.
Answers that should worry you. “We’ll handle all of that, don’t worry.” That sentence binds no one. A slipperier version is “everything within a reasonable scope is included” — then you push: what’s a reasonable scope? Who decides? If they can’t give you a standard, the clause is empty. Also, if the salesperson rushes back to the total price and says “if you go item by item like this, we can’t quote,” pay attention: a vendor who has done many projects knows these items cold. Not being able to answer usually means they never really assessed your project. For a fuller breakdown of quotation structure, read this alongside how ERP implementation costs add up.
Question 2: After we sign, if I want one more feature, how is it priced?
Why ask. I think this is the single most important clause in the contract. ERP projects will 100% have added requirements — not because the vendor is scamming you, but because there is no way you can think of every requirement before you see what the system actually looks like.
The problem: if the contract has no rules for additions, every addition is a fresh negotiation, held while you’ve already paid the deposit, data is already moving, and the schedule is already bearing down on you. Your leverage is zero.
What a good answer looks like. The contract has a clause setting out the process and pricing basis for added requirements. Specifically, three things. First, the unit rates for additions (consultant person-day rate, developer person-day rate) are fixed for the contract period and won’t jump. Second, a written process — you submit a request, the vendor replies with estimated hours and cost, and work starts only after your written approval. Nothing counts without your written approval. Put that in, so you never end up with “we already built it, you’re not going to pay?” Third, a line between “addition” and “should have been done anyway”: if you raised a feature during requirements interviews and they recorded it, it isn’t an addition.
Answers that should worry you. “Small stuff we’ll change for free.” Sounds generous, but who defines “small”? Late in the project the same sentence turns into “this one’s not small anymore.” Also watch for a total price with no rates — you ask how additions are priced and they say “we’ll quote you when the time comes.” That hands over pricing power completely. On how far customization should go and what shouldn’t be changed at all, I go into more detail in should your ERP be custom-built.
Question 3: From which year do annual maintenance fees start? Is there a cap on increases?
Why ask. Annual maintenance is the bulk of ERP’s long-term cost. You sign a one-time implementation project, but you use the system for ten years. Implementation is paid once. Maintenance is paid every year, and the total usually exceeds the owner’s gut feeling.
And this line is often vague on the quotation, e.g. just “Annual maintenance: from year two,” with no amount, no calculation basis, no increase rules.
What a good answer looks like. Four things need to be clear. First, the start point: one full year from the signing date, the go-live date, or the acceptance date? Second, the basis: a fixed percentage of the license fee, or a fixed amount? If it’s a percentage, does maintenance go up when I add user accounts later? Third, increases: the contract should state “maximum annual increase” or “no increase for the first N years,” not “the company may adjust as circumstances require.” Fourth, what maintenance actually buys: only version updates? Phone support? On-site visits? How many per year? Is there a response time (e.g. how fast someone responds when the whole system is down)?
Answers that should worry you. “We haven’t raised maintenance fees in years.” That’s past tense, not a commitment. You want a cap in the contract. Be especially careful with one structure: a very low implementation fee, a high locked-in maintenance fee, and a clause saying “maintenance may not be terminated early.” The total cost of ownership on that structure can be higher than the vendor who quoted more upfront. When you compare prices, spread maintenance over the same number of years, or the three quotations aren’t on the same basis — I explained how to do that conversion in how to choose an ERP vendor.
Group two: people — people decide the outcome, not the system
I have almost never seen an owner ask these questions on his own. But if you asked me to pick three must-ask questions out of the 12, I’d pick this group.
The reason is simple: within the same price band, the systems themselves differ less than you think. What creates the gap is who leads the project, whether they understand your industry, whether they get pulled away, and who your own company assigns to work with them.
Question 4: Who is the consultant actually leading this project? Are they here today?
Why ask. In the pre-sales stage you usually meet a salesperson plus a senior consultant or technical lead brought in to anchor the pitch. They speak clearly, use your industry’s jargon fluently, and nail your pain points — and after you sign, you never see them again.
The person who actually comes to your office every week and sits in the meeting room arguing with your accountant over the chart of accounts is someone you’ve never met. This isn’t fraud. It’s the normal division of labor in the industry. But normal doesn’t mean you can’t ask.
What a good answer looks like. The vendor can name the project consultant, their background, and the types of industries they’ve worked in, and ideally arranges for you to meet this person once before signing, for thirty minutes. You don’t need to test them. Just listen to how they describe your business. A consultant who really knows the work will ask you a few very specific questions in those thirty minutes: do your orders ship in partial batches, which costing method do you use, is physical stocktaking in your warehouse difficult. Someone who can ask good questions can build a good system.
An even better answer: they’re willing to put the lead consultant’s name in the contract or an appendix.
Answers that should worry you. “We’ll assign the most suitable consultant.” That says nothing. Another red flag: the strong senior consultant from pre-sales suddenly gets vague when you ask this question — that usually means he really won’t be on your project, and the vendor would prefer you didn’t find out before signing. And one more: “Who the consultant is doesn’t matter, we have a standard methodology.” Methodology matters, of course. But methodology doesn’t show up to meetings.
Question 5: What happens if the consultant is replaced midway?
Why ask. ERP projects often run for months. Consultants quit, get pulled to rescue other projects, take long leave. These things happen. The question isn’t whether it happens. It’s who absorbs the cost when it does.
The worst part of a consultant change isn’t a skill gap. It’s lost context. The previous consultant spent three months with you. They know which manager you can’t cross, which process the owner cares about most, why a certain report was revised four times. If none of that is documented, a new consultant means starting over. You hold another requirements interview, explain the same things again, and that time often gets counted as your project delay.
What a good answer looks like. The contract has a handover clause covering three things. One: a replacement must be notified to you in writing in advance, not after the fact. Two: the old and new consultants overlap and actually attend at least one or two meetings together, not a handover by email. Three: hours spent re-interviewing and re-explaining because of the change don’t count against your person-days and can’t be used as a reason for delay.
Some vendors will even write “changes to the lead consultant require the client’s consent.” That’s a strong answer, but don’t expect every vendor to give it.
Answers that should worry you. “Our consultant turnover is very low.” That answers a different question. Low turnover is good, but you asked “what if it happens.” Not answering directly usually means there’s no process. Also watch for “replacements are our internal staffing matter and won’t affect the project schedule” — “won’t affect” is a conclusion. What you want is who’s responsible if it does. Consultant quality and replacement risk are, in the cases I’ve seen of why ERP implementations fail, the most underestimated factor.
Question 6: How many people does our company need to put on this, and how many hours a week each?
Why ask. I’d put this in the top three questions “vendors most dread,” but not for the reason you think — not because the answer looks bad, but because an honest answer will scare you, and a dishonest one will blow up the project later.
ERP implementation isn’t a job you pay someone else to do. Your own company is half the project. Your people answer the interviews, clean up the data, confirm the parameters, run the tests, and sit through the training. That time is on top of their normal work, not instead of it — your accountant still has to close the books while you’re implementing ERP.
The most common mistake owners make is counting only the software side of the cost and leaving their own team’s time out completely. Once the project is running, the accountant is working until ten, the warehouse lead is complaining about more work, people start quietly resisting, and only then does the owner realize: the resource that was really underestimated isn’t money. It’s people.
What a good answer looks like. The vendor can lay out a concrete staffing structure: you assign a project lead (not in name only — they actually have to spend the time), each module gets a key user, weekly meetings run a fixed length, and certain phases need the most from your people. The best answer tells you directly which role carries the heaviest load and how much the schedule slips if your company can’t commit that time — a vendor willing to say that has usually actually done the work.
Answers that should worry you. “You won’t need to spend any time, we’ll handle everything.” This is the one dangerous line in this whole article I most want to warn you about. ERP cannot happen without your time. Anyone who says this either hasn’t done it or plans to let you find out after the project starts. By then, you’ve paid.
To get a feel for the actual time commitment, see the phase breakdown in ERP implementation timeline, and put your staff into the calendar before you sign.
Group three: delivery — make “done” mean the same thing to both sides
Money and people are settled. Next is the group most likely to end in a dispute: what counts as done.
I’ve seen too many projects stuck in the same place — the vendor thinks it’s delivered, the owner thinks it isn’t ready. Neither is lying. Nobody ever wrote “ready” down as something that can be verified.
Question 7: How is acceptance defined? Who signs? What do they sign?
Why ask. Acceptance is the switch for the final payment, the start of the warranty, and the line between the two sides’ responsibilities. For something this important, many contracts have only one sentence: “Acceptance will be conducted after system setup is complete.”
“Complete” is an adjective, not a standard.
What a good answer looks like. Acceptance criteria are a checklist you can tick item by item, in a contract appendix. A good checklist looks like this: a given process runs end to end (e.g. quotation, sales order, shipment, invoice, and accounts receivable all connect), specified reports produce correct output, imported legacy data matches the old system’s closing balances, and a specified number of users have completed training and can work independently.
The key is that every line can be answered with “can / can’t,” not “easy to use / not easy to use.” Also spell out the acceptance process: after the vendor submits for acceptance, how many working days you have to test; if there are problems, how you raise them, how many days the vendor has to fix them, and how retesting works. Also write down “what happens if acceptance fails,” or everyone gets stuck without knowing the next step.
Answers that should worry you. “Acceptance is just a formality, we’re all reasonable people.” When things are going well, that sounds considerate. When things go badly, it’s a disaster. Another dangerous clause: “If no objection is raised within thirty days of go-live, acceptance is deemed passed.” Auto-acceptance clauses aren’t unacceptable in themselves, but make sure someone is actually testing during those thirty days, and pair it with a clear channel for objections. Otherwise you’re waiving your rights by default.
Question 8: From which day does the warranty start? What does it cover?
Why ask. This extends the previous question, and it’s where wording games happen most. Two contracts with the same “one-year warranty” can give you protection that differs by months, depending on the start date.
More importantly: ERP problems usually don’t surface in the first week after go-live. They show up at the first month-end close, the first quarter-end close, the first stocktake, the first tax filing. If your warranty is too short to run through one full closing cycle, the warranty is decoration.
What a good answer looks like. The warranty starts from the date acceptance is passed, not the “go-live date” or “delivery date.” It lasts long enough to cover at least one full month-end close and one stocktake. If your industry has a clear annual cycle (a year-end shipping peak, annual stocktake, annual closing), ideally it covers that too.
Warranty scope needs to be clear as well: what gets fixed? The reasonable line is that anything where “the system doesn’t work as agreed” is covered — bugs, wrong report figures, agreed features not delivered. New requirements are not warranty. That’s fair to both sides. Don’t try to force it.
There should also be response times, ideally tiered: system completely down, partial functions unusable, general issues — each with its own response and resolution deadline.
Answers that should worry you. “The warranty starts from the handover date.” Then which day is handover? If it’s the day the server is installed, you could burn half the warranty before anyone has started using the system. Also watch for warranty scope written as “limited to program errors (bugs)” — because many disputes get classified as “this is a configuration issue, not a bug” or “this is user error.” The question to ask is: who decides whether it’s a bug?
Question 9: For how long after go-live are adjustments free?
Why ask. This is different from warranty. Warranty fixes “what was built wrong.” This question is about “what turns out to be awkward after go-live and needs fine-tuning.”
Almost every ERP project goes through this. It’s nobody’s fault. People can’t say what they want until they actually use it. Field order on a form, required fields, default values, report sort logic — all fine in the test environment, and then real work throws up a stream of “can we change this to…”
Without this clause, every one of those tweaks becomes an add-on quotation, one at a time. The amounts may be small, but your team will stop suggesting improvements because “changing one field needs a signed order,” and the system slowly becomes something everyone just puts up with.
What a good answer looks like. The contract has a “post-go-live adjustment period” that states its length and how much adjustment it includes (by number of changes, by hours, or something like “parameter and layout changes unlimited, code changes billed separately”). The point is a defined amount, not just “necessary assistance will be provided.”
You can also ask it another way: “Within three months after go-live, if we find a report’s fields need adjusting, will you charge for that?” Ask with a concrete scenario and the answer will be much clearer than asking about principles.
Answers that should worry you. “After go-live it’s under warranty, and we handle everything under warranty.” Sounds good, but warranty usually covers “errors,” not “adjustments.” What you need to check is whether the two are being lumped together. If they are, one line later — “this isn’t an error” — lets them push all of it back to you.
One table: the same question, good answer vs dangerous answer
The first nine questions covered a lot. I’ve put the ones most easily confused into one comparison table. Print it out and keep it on the table during meetings.
| Your question | Dangerous answer (vague, not binding) | Good answer (can go in the contract, verifiable) |
|---|---|---|
| Does the quotation include these items | “Everything within a reasonable scope is included” | Item-by-item in or out, with quantities (number of training sessions, number of tables migrated) |
| How are added requirements priced | “Small stuff free, big stuff we’ll see” | Fixed person-day rates + written approval process; nothing billable without written approval |
| How is maintenance charged | “We haven’t raised it in years” | Start date, calculation basis, annual increase cap, service scope and response times |
| Who is the project consultant | “We’ll assign the most suitable one” | Name and background given, meeting arranged before signing, name in an appendix |
| What if the consultant is replaced | “Our turnover is very low” | Advance written notice + overlap period + re-explaining hours not counted against your person-days |
| How many people do we need to commit | “You won’t need to spend any time” | Named roles, weekly hours, heaviest phases, schedule adjustment if commitment falls short |
| How is acceptance defined | “Acceptance is just a formality” | Tickable checklist + testing days + process for failed acceptance |
| When does the warranty start | “From the handover date” | From the acceptance date, covering at least one full month-end close and stocktake |
| Free adjustments after go-live | “We handle everything under warranty” | Defined period + defined amount of adjustment, with “errors” and “adjustments” separated |
| Who owns the data | “Of course the data is yours” | Ownership clause + export in readable formats + delivery deadline and fees |
| Who owns the custom-built code | “That’s no problem” | Defined license scope or copyright ownership, including the right to maintain it yourself later |
| Vendor stops service | “We’ve been around too long to go under” | Notice period for termination, data return procedure, custody arrangements for key documents |
You don’t need to memorize the table. Just remember one rule: any answer without a quantity, a date, a person, an amount, or a process is empty.
Group four: exit — the most awkward, but now is your only chance to ask
This is the group owners are most reluctant to raise. Many tell me: “Asking what happens if you go under before we’ve even started working together — isn’t that a bit rude?”
I understand the feeling. But look at it another way: if you don’t ask these three now, you will never get to ask them. The day you need the answers is usually the day the relationship has already broken down, and by then you have no leverage at all.
And honestly, the vendors who should be happiest to hear these three questions are the good ones. Good vendors can answer them, and being able to answer is exactly what separates them from the rest.
Question 10: Who owns the data? When I want it back, in what format?
Why ask. Your customer list, transaction records, inventory movements, cost structure — these are your company’s real assets. Systems can be replaced. Data can’t be recreated.
And almost every vendor will say “the data is yours.” The problem is, ownership and access are two different things. If the data sits in their database, stored in their structure, and you own it on paper but can’t actually get it out, the ownership means nothing.
This matters even more with cloud subscription systems — on-premise at least means the data is in your server room. With cloud, you don’t even know where the files are. If you’re still deciding which way to go, cloud vs on-premise ERP breaks down the difference in control between the two.
What a good answer looks like. The contract needs three things. First, it states that ownership of operational data belongs to you, and the vendor only processes it to perform the contract during the service period. Second, export format and scope: export to common readable formats (e.g. CSV, Excel, or a standard database backup file), including master data and transaction details, not just a few reports. Third, the terms for getting it: on termination or on your request, how soon it’s delivered, whether there’s a charge, and how much. This one must be written down, or “we can give it to you, but we’ll need to assess the cost” becomes a bargaining chip.
If you can go one step further, ask for documentation of the table structure (field definitions, relationships). That makes any future move to another system much smoother.
Answers that should worry you. “Of course the data is all yours.” And then nothing more. Push on format and timing. Another line to watch for: “We can export it for you, but that’s a custom request and needs a separate quotation” — which is actually true when the contract doesn’t say otherwise. So make it a contractual obligation before you sign.
Question 11: Who owns the custom-built code and the source code?
Why ask. Separate two things first. The source code of the packaged software itself normally won’t be given to you, and that’s reasonable — you bought the right to use it. Don’t get stuck on that. But the custom code developed just for you — the part you paid for, written specifically for your company — that ownership is negotiable.
Why does it matter? If the vendor holds all rights to the custom code, then later you can’t switch maintenance vendors, can’t hire someone to make a small change, can’t even find out how a piece of logic calculates. How locked in you are is proportional to how much is custom-built.
What a good answer looks like. Handle it in layers. Don’t insist on source code for the standard product, but get assurance on version updates. For the custom-built part, at least secure a “non-exclusive license” — meaning you have the right to use it, modify it, and hire a third party to maintain it. Better still, agree that copyright belongs to you, or is jointly held.
There’s also a very practical option called source code escrow: the source code is held by a third party. Normally you can’t access it, but it’s released to you if specific conditions are met (e.g. the vendor goes out of business or can’t fulfill its maintenance obligations). Not every vendor can do this, but you can ask, and their reaction is information in itself.
One more thing that often gets overlooked: custom spec documents and table structure documents. Even if you can’t get the source code, having these two documents makes life much easier for whoever takes over later. This request is rarely refused, because it costs the vendor almost nothing.
Answers that should worry you. “Source code is our company secret, there’s no way we’ll give it to you.” If he means the standard product, that’s a normal answer and you shouldn’t be upset. But if he won’t give you even the part you paid to have developed, or even the spec documents, rethink whether too much of this project is custom-built. The more custom work, the deeper the lock-in. At that point, what needs a second look is the requirements, not the clauses.
Question 12: If your company shuts down or decides to discontinue this product line, what happens to me?
Why ask. Software companies close, product lines stop getting updates, distribution rights change hands. These are real possibilities in the industry. You’re not cursing them. You’re managing risk — the same way buying insurance doesn’t mean you expect something to happen.
And this question does something useful: it’s a truth detector. Their reaction tells you a lot.
What a good answer looks like. They’re willing to discuss it directly and can describe concrete arrangements. For example: how much advance written notice for termination of service; the data return procedure on termination (continuing from Question 10); what happens to prepaid but unused maintenance fees; how key documents (data structure, custom specs, system configuration notes) are kept; and for cloud services, whether there’s a transition arrangement to move the system and data to self-hosting or another environment.
An even better answer: they volunteer their product support policy — how long this version will be supported, how customers are notified when an old version reaches end of support. A vendor who can explain their product lifecycle policy usually has proper internal management.
Answers that should worry you. First: “We’ve been around this long, that won’t happen.” That’s dodging, not answering. Second, more subtle: they’re visibly annoyed and feel you’re doubting their company. What matters here isn’t the annoyance itself, but that they mistook “risk management” for “a personal attack”. It suggests the company isn’t used to being examined. Third: a vague “we’ll definitely take care of that when the time comes” — when is that time? Who takes care of it?
Honestly: will asking these questions offend the vendor?
I know what you’re thinking at this point. If I ask all 12, will they think I’m difficult, that I don’t trust them, and just walk away from the project?
My answer has two layers.
First layer: asking these questions isn’t distrust. It’s aligning expectations.
When ERP projects end in fights, eight times out of ten it’s not because someone wanted to cheat. It’s because both sides pictured the same thing differently. You thought custom reports were included; he thought they were extra. You thought go-live meant every module switched over; he thought the first module running counted. You thought the consultant would see it through; he thought a handover was normal staffing. Settle these gaps at signing and it costs a few hours of meetings. Let them blow up mid-project and it costs delays, broken trust, and your team’s morale.
So these 12 questions protect the vendor too. Clear scope means he isn’t buried in endless additions mid-project. Clear acceptance criteria mean he actually collects the final payment. Clear commitments from your side mean he doesn’t carry the blame alone when things slip. A consultant who has done dozens of projects usually feels relieved when a client is willing to settle these things up front.
Second layer: a vendor who actually gets angry at these questions is one you shouldn’t work with anyway.
I’m being blunt, but I mean it. You’re asking “how far does this money go,” “who does the work,” “how do we know it’s done,” and “can I take my data with me.” These four are the basics of any normal business deal. You’d ask them when buying a machine. If a company is offended just by being asked, what do you think happens when you’re halfway through and a real dispute comes up?
Here’s what I’ve actually seen: when a good vendor gets these questions, the usual reaction is “I need to check this, I’ll get you a written reply next week.” They won’t necessarily give you the best terms on every question — some things are company policy and can’t change — but they answer directly and put in writing what they can.
A bad vendor’s reactions cluster around changing the subject: steering you back to the total price, stressing company size, stressing case counts, stressing “this is how we always do it.” Not everyone who says these things is a bad actor. But if you ask three questions and all three get deflected, you already have your answer.
One last point I think matters: these 12 questions aren’t for haggling. They’re for deciding whether to sign. If you use them as a haggling tool, the vendor will offer a discount in exchange for you dropping the follow-ups, and you lose. Price can be renegotiated. Unclear scope can’t be fixed.
Frequently asked questions
Can I change the terms of an ERP contract? Vendors usually say it’s a standard contract and can’t be touched
“Standard contract” is usually a negotiating line, not a fact. For most ERP contracts, the main terms really are hard to change, but appendices, specifications, acceptance checklists, and requirement lists are almost always negotiable, and most answers to the 12 questions in this article go into appendices. So don’t focus your strategy on “changing terms.” Focus on “adding appendices.” The most effective approach in practice: compile the answers you got into a “mutually confirmed items” document, have the vendor sign it, and attach it to the contract. That leaves the structure of the main contract alone, and their legal team pushes back far less. If they won’t even add an appendix, the question isn’t about clauses anymore. It’s whether this company actually wants the project.
When should I ask these 12 questions? Is asking on signing day too late?
Don’t leave it to signing day. The best time is when you’ve narrowed it to two vendors but haven’t told either who won — your negotiating position is strongest then, and they’re most willing to cooperate. If you’ve already verbally committed to one, or already told the others no, you’ve lost half your leverage. In practice I suggest asking in two rounds: during quotation comparison, ask the six money and people questions, because they affect how you compare prices. Once you’ve decided to proceed and moved into contract review, ask the six delivery and exit questions, because those need to be written as specific language and require their legal team. On signing day, do only one thing: confirm that everything agreed earlier is in the contract.
The vendor says a lot of my requests cost extra. Am I being ripped off?
Not necessarily. It depends on what they’re charging for. If you’re asking for extra work — more training sessions, more years of historical data migrated, more reports built — charging is reasonable. They have staff costs too. What you should push for isn’t free, it’s transparent pricing, stated up front. But if they’re charging for things you should have anyway — exporting your own data to you, providing table structure documentation, documents proving acceptance passed — that deserves a question mark. The rule is simple: is this “an extra service” or “something you should already own”? Charging for the first is reasonable. Charging for the second is building switching barriers.
I already signed before reading this. Can I still fix anything?
Yes, and the sooner the better. Here’s how: go through the 12 questions against your contract one by one, circle the ones you can’t find answers to, then proactively schedule a project kickoff meeting with the vendor, raise those items as “project agreements” for discussion, and have both sides sign the meeting minutes to confirm. Vendors early in a project are usually willing to cooperate, because they don’t want fights later either. The two most important are acceptance criteria and the warranty start date. Adding these early in the project isn’t hard. Raise them close to go-live and the vendor will feel you’re changing the rules. The worst thing to do is “say nothing now and blow up when something goes wrong” — by then you’ve paid most of the money and have little leverage left.
Does a small or mid-sized company really need to put this much effort into the contract? Our project isn’t that big
The smaller the project, the more you need to read it. The reason: when a big company hits a problem, it has legal, budget, and alternatives. When a small company hits a problem, it just stops. Your accounting team is two people — if the system goes down, nobody can issue invoices. Your warehouse is that one veteran — if he can’t learn the system, there’s no backup. Small and mid-sized companies can absorb less risk, so getting things clear up front pays off more. And these 12 questions don’t take much of your time — ask them properly and you’re done in one or two meetings, in exchange for years without constant fights. If you haven’t even worked out what you need yet, I’d suggest not rushing to sign. Do the requirements inventory first; the full sequence is in the SME ERP buying guide.
Last word: a clear contract protects the working relationship
Back to the line at the top: “I’ve read the contract. Nothing wrong with it.”
I hope that after reading this you understand one thing: a contract with nothing wrong in it is not the same as a contract that’s clear. A contract with no errors and no substance is completely harmless when things go well and completely useless when they don’t. And with ERP implementation, the odds of running the whole way without a single problem are, frankly, not as high as you think.
You don’t need to ask all 12 at once, and you don’t need the best terms on every one. What you need is to know which ones the vendor can’t answer — those are the real risks in your project, and you can decide whether to accept them, negotiate, or switch vendors.
If you happen to be stuck right at the signing stage and can’t get concrete answers on a few questions no matter how you ask, print out these 12, circle the ones that went unanswered, and bring them to us for a free diagnostic. We won’t rush to push our own system — honestly, many owners finish these 12 questions and conclude “I shouldn’t be signing this contract at this stage at all.” That’s a good conclusion too, and reaching it early is far cheaper than reaching it late.
Before you sign, you can ask anything. After you sign, all you can do is hope the other side is a decent person.




