Selecting and negotiating with your system implementer

Scope the project and build your own bottom-up plan and budget first. Then write a statement of work and project plan detailed enough to fold into the contract by reference. If your understanding of scope lives only in the vendor's proposal, you've already conceded the ground that matters.

Run a real competition and hold every bidder to the same assumptions, the same timeline and the same cost template. Let each firm propose its own scope and you can't compare the bids, and each one gets room to hide scope in the gaps. Ask for the resumes of the actual proposed team, and require the leaders who'll run the program to show up at the oral presentations. The people who pitch should be the people who deliver.

The software decision and the integrator decision have different criteria, different failure modes and different people across the table. Run them in parallel so you can sign both before design starts, and score them apart.

The failure to avoid is letting the software vendor hand you the integrator. Every platform vendor has partners it prefers, and a warm introduction isn't a competitive process. The partner that's easiest for the vendor to recommend is rarely the one with the deepest bench in your industry at your scale.

The healthcare exception

In Epic shops this two-track model is starting to break down at one end. Epic implements and supports its own ERP applications with Epic staff, so there's no competitive integrator market behind EpicOps the way there is behind Workday and Oracle. That removes a category of risk, and it removes a lever at the same time. If that's your situation, price and terms are a single negotiation with a single party, and the selection work happens entirely on the software side. I've written that up separately.

A scorecard built after the demos is a justification. Agree the criteria and the weighting with the steering committee in writing before any vendor presents, so nobody can reverse-engineer the model to a preferred answer later. That's also what makes the decision defensible five years out, which is the real test.

Weight toward the drivers of failure. Common starting points put around 40% on functionality and spread the rest across delivery risk, security and vendor stability. Here's the weighting from an actual dual-platform selection I ran, a core ERP and a workforce system evaluated in parallel.

Leverage comes from a capability-first selection that makes every bidder compete on the things that actually cause failure. When price is 10% of the award, a vendor can't buy the deal, so it has to win on method.

Script the demos against your own data

A sandbox demo proves the software works in the vendor's sandbox. Write the scripts yourself, hand the same ones to every bidder, and build them from the scenarios that hurt today: your general ledger structure, your item master, a payroll scenario at your real complexity, the month-end close. Two strong platforms look identical in a canned demo and separate immediately under your own data.

Implementation services are the biggest number in the deal. Professional services fees typically run 1.5 to 3.5 times the annual software cost, and on Workday programs the reported range is 2 to 4 times the year-one subscription. Implementation, data migration, training and change management together account for roughly 50% to 70% of first-year spend. The license is often only 20% to 30% of it.

Subscription or license

20 to 30%

Services, migration, training, change

50 to 70%

Your own people, backfill and the work nobody budgeted

The rest

025%50%75%100%

Change management is the line cut first. It's trimmed at kickoff on roughly 7 of 10 programs and comes back later as a 10% to 20% overrun, so cutting it moves the money and adds risk.

Build the model out to ten years, because that's the horizon the decision is actually made on: subscription plus escalation, implementation, integration, internal backfill, ongoing support headcount, and the second-wave modules everyone knows are coming but nobody puts in the business case. Year one always looks close between two finalists. Year six is where the answer lives.

Buyers concede this term more often than any other. It sits in a subscription schedule instead of the contract body, costs nothing in year one, then compounds every year after.

Workday's standard renewal formula combines an Innovation Index, nominally around 5%, with a CPI adjustment of 1% to 3%. That produces compound annual increases of 5% to 8%, and 8% to 10% in recent cycles. Oracle Fusion SaaS uplifts of 5% to 12% are common. On the Oracle support side, the median renewal uplift runs about 6% a year against the 4% cap most buyers assume they have, and roughly 41% of capped renewals exceed the cap anyway. A cap is a negotiated clause you have to write into the order document. You don't get one by default.

Here's what the difference looks like on a $2 million subscription over a five-year term.

Year	With a 3% cap	Uncapped at 9%	Gap
Year 1	$2,000,000	$2,000,000	$0
Year 2	$2,060,000	$2,180,000	$120,000
Year 3	$2,121,800	$2,376,200	$254,400
Year 4	$2,185,454	$2,590,058	$404,604
Year 5	$2,251,018	$2,823,163	$572,145
Five-year total	$10,618,272	$11,969,421	$1,351,149

Five-year gap$1,351,149

1. $0Year 1
2. $120,000Year 2
3. $254,400Year 3
4. $404,604Year 4
5. $572,145Year 5

Arithmetic on a $2,000,000 base. No discount you win at signature is worth $1.35 million, and the cap can only be set at renewal or at original signature, never mid-term.

Four more terms that belong in the subscription schedule

Growth bands

If your headcount is going from 29,000 to 35,000 over the term, price that now. Otherwise every acquisition triggers a repricing at the vendor's list, at a moment when you have no alternative.

Acquired-entity pricing

Related, and separate. Health systems, universities and manufacturers all acquire. Agree in advance what an acquired entity costs to add, and on what notice.

The AI line, priced explicitly

AI feature bundles typically add around 5% of annual contract value, roughly $50,000 a year on a $1 million contract. Price and cap it as its own line so it doesn't arrive folded into a renewal.

Co-term everything

Pull add-on modules onto a single anniversary so future negotiations happen once a year, instead of piecemeal across four quarters with four different account teams.

Two clocks run in every software negotiation, and buyers forget the dangerous one. The first is the expiry date. The second is the non-renewal notice window, which on Workday agreements typically requires written notice up to 120 days before expiration. Miss it and the contract auto-renews at the vendor's standard uplift. The conversation you were preparing for no longer exists.

Vendor fiscal calendars are the other half. Workday's fiscal year ends January 31, which makes November 1 through January 31 the period of greatest discount flexibility, because account teams are closing against annual quota. Oracle's fiscal year ends May 31. Start substantive talks a quarter ahead of the vendor's year end so there's time to build the internal approvals that deeper discounts require, then close into it.

1. 12 months outUsage audit, benchmarks
2. 120 days outNotice window closes
3. Aug to OctOpen substantive talks
4. Nov to JanClose into the vendor's Q4

Serve the non-renewal notice inside the window even if you fully intend to renew. It keeps the contract open at no cost. Miss it and the vendor tells you the renewal terms instead of negotiating them. Nine to twelve months of preparation is the runway. Teams that start 90 days out negotiate under their own deadline instead of the vendor's.

Most SI contracts are drafted by the SI. The standard forms limit termination to material breach, restrict your remedy to re-performance, disclaim anything said during the sales cycle, and cap damages at the fees you paid. Read plainly, you're paying for the privilege of having no real remedy when the project fails.

Four patterns show up on nearly every troubled program.

1. The people who win the deal aren't the people who deliver it. The senior experts rotate off once the ink dries, and you inherit a team you never met.
2. Scope is left deliberately soft, so "standard configuration" and "core functionality" become billable negotiations later, once switching partners is unthinkable.
3. Acceptance is engineered around payment instead of outcomes, so the firm collects most of the contract value before you've proven the system runs your business.
4. The incentives point the wrong way. A time-and-materials partner has no reason to be efficient, and a fixed-fee partner has every reason to define scope narrowly and bill the rest as change orders.

None of this is hypothetical. Public disputes over failed programs have run into tens and hundreds of millions of dollars, and the through line in the post-mortems is almost never the software. It's a contract that never protected the buyer.

Time and materials

You pay for actual hours at agreed rates, and you carry the cost and scope risk. It's the honest choice when requirements aren't stable yet (early discovery and design, complex integration, cutover support) because you avoid paying for padding on work nobody can size. Its weakness is that it gives the firm no reason to be efficient, and open-ended time and materials is one of the most common causes of overruns. The control sits in governance: milestone discipline, not-to-exceed caps and the willingness to say no.

Fixed fee

You pay a set price for a defined scope. On paper the risk shifts to the SI. In practice the firm claws it back two ways. It defines scope narrowly and bills everything else as a change order, and it prices a contingency buffer into the fee, so a smooth project means you overpaid for risk that never arrived. A fixed fee only protects you when the scope it's fixed against is genuinely complete. Otherwise you've bought a fixed price for an incomplete deliverable.

Match the instrument to the phase. Run discovery on time and materials so scope stabilizes, lock a fixed price once it's defined, and cap the volatile phases. Stabilizing scope first also shrinks the contingency.

The change order is the SI's most reliable profit lever, and the good firms use it on purpose. The plays are predictable. Functional scope gets clarified after design and testing. Data migration is understated, with the firm taking only the last mile of loading and leaving you the cleansing. Assumptions turn your slow decisions into grounds for a change order. Integrated testing surfaces the issues you own, and they become schedule-delay change orders.

Write the statement of work as a project plan with binding commitments, with milestones and acceptance criteria for each phase, tied to the agreement by defined terms and dates. Use a responsibility matrix and avoid the phrase "joint responsibility," because ambiguity is the firm's friend. Contract the implementation services separately from the software license, and add a joint-accountability clause so the software vendor and the SI can't each blame the other. Run every change through a written impact assessment and a change board with defined authority. Price all changes against a rate card you agreed before any work began, so the firm can't reprice when your leverage is weakest.

Assumptions deserve special attention. Every statement of work has an assumptions section, and it's one-sided because buyers concede it. Rewrite the classics.

As drafted

"Client is responsible for addressing software errors from the software provider."

Rewrite to

"The SI will assist and support the client."

As drafted

"Scope is limited to modules X, Y, Z."

Rewrite to

Every geography, legal entity and business unit named, in scope or out.

Then give every assumption a named owner and put it in the program risk log at kickoff. An unmanaged assumption is a scheduled change order.

The bait and switch, the A-team in the pitch and the B-team in delivery, is the most common and least contested failure in the whole relationship. Firms rotate their senior leaders off over time, and understaffing runs through nearly every major implementation lawsuit. The counter is a set of key-personnel terms that outsourcing lawyers treat as standard and vendor forms quietly leave out.

Name the key roles in the contract: executive sponsor, engagement lead, delivery lead, solution architect, and the integration and data-conversion leads. For each one, require your prior written approval before any substitution, with replacements of equal experience. Require 15 to 30 days notice of any change, and require that knowledge transfer for a replacement happens at the firm's cost. Keep resume and interview rights, and the right to remove someone who isn't working out. Add a turnover provision that tracks attrition on your account with a remediation trigger, and ask for an updated staffing model at regular intervals so you can see erosion before it hurts you.

Implementation performance is measured against milestones, deliverables and acceptance criteria: discrete events that ask whether it's done and whether it conforms. Run-phase service levels measure continuous outcomes like availability and response times against standing targets. A firm can hit 99.5% uptime on a system that still can't close your books. During the build, govern quality through acceptance of deliverables, and refuse any attempt to swap a vague hypercare window for defined acceptance.

Build a real acceptance framework. Translate each requirement into a testable pass or fail threshold. "The system shall support month-end close" becomes "month-end close completes within five business days with all reconciliations balanced and regulatory reports generated without manual intervention." Structure acceptance in tiers (deliverable, integration testing and user acceptance) and attach the largest payment holdback to the most demanding tier.

Then disarm the deemed-acceptance traps. Make the review windows extendable minimums so your testing time is never read as acceptance by silence. Reject the "material nonconformance" standard so any missed criterion is grounds to reject. State that neither payment nor ordinary use counts as acceptance.

Attach money to acceptance. Hold back 20% to 30% of fees, released only on final acceptance and a stabilization period. Cap the number of cure cycles before the firm is deemed to have failed, so you aren't stuck in an endless fix-and-retest loop. Keep service credits as one remedy among several, and preserve your right to withhold payment on a disputed charge without the firm downing tools.

Vendor-favorable boilerplate does its quietest damage here, because it looks like standard legal language and is easy to wave through. Read it as the firm's estimate of how little it intends to be accountable for.

On liability, vendor forms exclude consequential damages and cap direct damages at a slice of fees, often 6 to 12 months, sometimes tied only to the specific work order. The math is brutal: a large loss against a fees-based cap can mean recovering a few percent of your actual damage. The number matters less than the carve-outs, the categories that escape the cap or get a higher one:

• Data loss and security breach
• IP infringement
• Breach of confidentiality
• Gross negligence
• Willful misconduct
• Violations of law

Those are the events most likely to cause catastrophic loss, and the standard form keeps every one of them inside the fees-paid cap. A data super-cap and uncapped liability for fraud and gross negligence are standard asks worth holding the line on. Watch for a short contractual clock, too: 12 to 24 months, which can expire while you're still trying to remediate.

On indemnity, vendor forms narrow the firm's obligation to third-party IP claims while your indemnity of them stays broad. Push for mutuality, and insist that the IP and data-breach indemnities sit outside the liability cap. On warranties, secure two: that services are performed in a professional and workmanlike manner, and that deliverables conform to their specifications for a defined period, with defects fixed at no cost. Resist the blanket disclaimer of all implied warranties. Require insurance sized to the exposure (professional liability, cyber, and technology errors and omissions) with you named as additional insured, because an indemnity is only as good as the ability to pay it.

The buyer-friendly default most people assume often doesn't apply. Many vendor forms give the firm ownership of everything it creates, including your configurations, and hand you a license. Ownership of custom code doesn't pass to you automatically, so without a present assignment the work-made-for-hire label may transfer nothing.

Negotiate three things.

1. A present assignment of the foreground work built for you (the deliverables, custom code and configurations), carving out the firm's genuine background tools and accelerators, which you only need a license to.
2. A broad, transferable license to any background IP embedded in your deliverables, including the right to have a third party maintain and further develop the work, so a successor can take it over.
3. Guardrails on residual-knowledge and reuse clauses, confined to unaided memory and conferring no ownership of your IP.

Where the firm or the software vendor owns critical code, negotiate source-code escrow with real release triggers.

Governance is a contractual structure of matched decision tiers, timed escalation and a duty to keep working while you disagree. It keeps a struggling program from becoming a stalled one, which a status meeting where everyone reports green never will. Build three tiers over the delivery teams, staffed at matching levels on both sides so peers escalate to peers.

1. Executive sponsorCommitments and escalationsTypically quarterlyExecutive sponsor
2. Program leadStatus and risk across workstreamsTypically monthlyProgram lead
3. Workstream leadActivities and blockersWeekly or per sprintWorkstream lead

Give the escalation ladder a clock. If the working tier can't resolve a matter within a set number of business days, it escalates automatically to named senior roles, who get a further set window to resolve it. Structure the dispute clause in steps, from good-faith negotiation to executive negotiation to mediation to arbitration or litigation, and settle the governing law and venue up front instead of accepting the firm's home jurisdiction.

Above all, include a duty for both parties to keep performing their undisputed obligations while a dispute is resolved. In a crisis, the most valuable provision you have is the one that keeps everyone working while the adults sort it out.

The day you need transition assistance is the day the firm has the least reason to give it, so the obligation, the duration and the cost basis all have to be locked before you sign. Standard forms are thin here on purpose. A dependent customer is a profitable one.

Secure termination for convenience on reasonable notice and for cause with a cure period, and on termination pay only for services properly rendered to that date. Make transition assistance real: continued services for a defined period, active help moving to you or a successor, no degradation of service levels during the wind-down, and a favorable cost basis. Require knowledge transfer and data return, complete documentation within a fixed window of a termination notice, and structured-format data exports so you aren't paying to re-key or re-convert.

Design against lock-in from the start. Own or directly license the critical assets, require deliverables built to be transferable, and keep a right to hire key people on exit. Without the outgoing firm's cooperation, even generous termination rights leave you stranded.