Enterprise systems run most of the world's companies — and replacing one is the biggest bet a business ever makes on software. This is the story of the days the switch was flipped.
Easier version: read this lesson at A2/B1 level →
Ten items. Work through the four activities — say your answer out loud before you reveal it.
Three terms: rollback · migration · legacy system. Say the right one, then reveal.
Read each part. After it, there's a quick check (answer from memory first), then one question to discuss. Customer companies are named; the software vendors — several different ones across these stories — are deliberately not: the pattern belongs to the projects, not to any product.
First, understand the bet. An enterprise system replacement is not an IT purchase; it is open-heart surgery on a running company. Every order, invoice, pallet and payslip must keep flowing while the organs that process them are swapped. The projects run for years, cost from tens of millions into the billions, and consume armies of consultants — an entire global industry exists just to implement them. Boards approve them for a genuine prize: one system, one set of numbers, one version of the truth, replacing the tangle of aging legacy systems held together by three specialists near retirement. Roughly half of these projects, decade after decade of surveys agree, end up seriously over budget, behind schedule, or worse. The stories that follow are the "worse".
The genre's founding legend is Hershey, 1999. America's biggest chocolate maker was replacing its core systems and, running late, made two decisions that now appear in textbooks with red circles around them: it compressed the testing schedule to protect the date, and it chose a big-bang go-live — everything at once — in July, precisely when orders for its two biggest seasons, Halloween and Christmas, come flooding in. The new system came up; the flow of orders through it did not. Warehouses held over a hundred million dollars of Kisses and Jolly Ranchers that the system could not steer onto trucks. Shelves went empty in the most chocolate-critical quarter of the year, sales fell, the share price dropped sharply, and business schools acquired their favourite opening slide: the company that had the chocolate, had the customers, and lost Halloween in the software between them.
Hershey survived, fixed it, and later completed upgrades smoothly — a detail the legend drops but this series keeps: the same company, chastened, became a case study in doing it right. The lesson was never "systems don't work". It was that a go-live date had been treated as a promise to the calendar instead of a conclusion from the testing — and the calendar, unlike the testing, cannot tell you anything.
1. Why is an ERP replacement "open-heart surgery", and what is the prize that justifies it?
2. Name Hershey's two red-circled decisions and their consequence.
1. The business must keep running while its core processes are replaced — years, nine-figure budgets, consultant armies. The prize: one system and one version of the truth instead of a fragile tangle of legacy systems.
2. Compressing testing to protect the date, and a big-bang go-live in July — straight into Halloween and Christmas ordering. Over $100m of candy sat unshippable, sales and the share price fell, and the case entered every textbook.
The pattern repeats with the reliability of physics, and the catalogue is worth reading like a coroner. FoxMeyer, in the mid-1990s, is the extreme case: a five-billion-dollar drug distributor bet on a new ERP and an automated warehouse simultaneously, while also signing aggressive new contracts priced on savings the unbuilt system was supposed to deliver. Orders misfired, stock vanished into the automation, costs exploded — and in 1996 the company collapsed into bankruptcy and was sold off for a fraction of its size. The trustees sued the software maker and the consultants for hundreds of millions; the settlements are confidential; the corpse is not. It remains the reference answer to "can a software project actually kill a company?"
The gentler entries rhyme. A US utility went live on schedule in 2012 — in the same week a hurricane devastated its service area — because contract penalties and project fatigue made the date immovable; payroll promptly broke, workers were overpaid, underpaid or unpaid through the storm recovery, and the total repair bill ran toward a billion dollars. A famous cosmetics company's 2018 go-live jammed its main distribution centre so badly it could not fulfil orders from its biggest customers — and it learned the modern coda: shareholders now sue over botched go-lives, arguing the risk was known and understated. A major British city council's finance-system project ran so far over — from tens of millions towards ten times that — that it became a contributing factor in the council's effective bankruptcy. And in the industry's most discussed anti-disaster, a giant European discount retailer simply stopped: seven years and roughly half a billion euros into its programme, it cancelled the whole thing and returned to its old system — reportedly because the software assumed one way of valuing inventory and the company refused to abandon its own. Ridiculed at the time as waste, the decision has aged into grudging respect: it is the catalogue's only entry where somebody pulled the plug before the go-live did it for them.
Read as one text, the catalogue keeps confessing the same three sins. Testing compressed to protect a date. Complexity multiplied by customisation — every "but we've always done it this way" hard-coded into the machine at premium prices. And the sunk-cost engine from this series' other cases: with two hundred million spent, no executive can afford to be the one who stops — so the only acceptable direction is forward, which is how a late project becomes a disaster instead of just a late project.
1. What makes FoxMeyer the extreme case?
2. Why has the abandoned half-billion-euro project aged into respect?
1. A $5bn distributor attempted ERP plus warehouse automation at once, priced new contracts on savings the system hadn't yet delivered, lost control of orders and stock — and went bankrupt in 1996. The project didn't damage the company; it ended it.
2. Because it is the only case where leadership stopped before go-live: seven years and ~€500m in, the retailer refused to let the software rewrite how it ran its stock, cancelled, and kept its working old system. Everyone else's disasters made its "waste" look like discipline.
Strip away the technology and every entry in the catalogue is the same collision: standard software encodes one way of running a business, and a company is a thousand people's habits pretending to be processes. Go-live is the moment those two meet without an interpreter. That is why the projects are hard in a way that building a bridge is not: the bridge does not argue back. The industry's own veterans put it as a fork — change the software to fit the company, and inherit complexity forever; or change the company to fit the software, and fight every department whose "always" is being deleted. The failed projects almost all tried to do the first while claiming to do the second; the famous cancellation happened because one company understood the fork and refused both prongs honestly.
Two quieter truths complete the picture. The successes are invisible by definition — thousands of companies cross these go-lives every year without headlines, usually the ones that tested until the testing said yes, went phased instead of big-bang, cleaned their data before moving it, and treated the project as business change with software attached rather than the reverse. And the game never ends: entire generations of these systems are now reaching end-of-support, pushing a worldwide wave of migrations to newer cloud versions on vendor deadlines — thousands of companies queued for their own go-live day this decade, consultants scarcer and dearer than ever, every board reading the old catalogue nervously. The people who carry these projects — the analysts, consultants and administrators who translate between the company's habits and the system's rules — have quietly become some of the most consequential people in any business: the interpreters at the collision.
So the case ends where the practitioner lives, with the question every project in the catalogue answered too late: when the company's way and the system's way disagree, who decides which one bends — and is that person in the room? Companies that can answer before the go-live get the boring, invisible success. Companies that can't find out on the day the switch is flipped — with the trucks waiting, the payroll due, and Halloween coming.
1. What is the fork, and how did the failures typically handle it?
2. Why are the successes invisible, and what wave is happening now?
1. Change the software to fit the company (permanent complexity) or change the company to fit the software (organisational war). The failures tried the first while claiming the second — customising heavily under a banner of standardisation.
2. Because a smooth go-live makes no news: tested-until-yes, phased, clean data, business change first. Meanwhile end-of-support deadlines are pushing a global wave of migrations to newer cloud versions — thousands of go-lives queued this decade, with the catalogue as bedtime reading.
English has a small set of verbs whose meaning flips depending on whether -ing or to follows — and project language leans on exactly these verbs: stop, try, remember, forget, regret, go on, mean. Get the pattern wrong and your status report says the opposite of the truth.
Complete with the correct form of the verb in brackets, then say aloud what the sentence means.
1. Under deadline pressure, the team stopped (run) the full test suite entirely.
2. Hershey went on (complete) later upgrades without incident — the chastened sequel.
3. We regret (inform) you that the launch has been moved to the first quarter.
1. running (the activity ended — the fatal reading)
2. to complete (the next stage in the story, not more of the same)
3. to inform (formal bad news now)
Write both versions and state the difference. Full sentences.
1. (stop / test) The night before go-live, they stopped — versus — they stopped
2. (try / phase) The steering committee tried the rollout — versus — tried the rollout on schedule.
3. (remember / migrate) The team remembered the archive — versus — remembered the archive last spring.
1. stopped testing (gave up on tests) / stopped to test (paused for one more test)
2. tried phasing (experimented with a phased method) / tried to phase (attempted it, probably against resistance)
3. remembered to migrate (did the duty) / remembered migrating (has the memory of doing it)
Fill each gap with -ing or to + verb, then read the findings aloud.
The programme began well: the team remembered (clean) the master data and tried (pilot) the system in two small markets first. But when the schedule slipped, leadership stopped (listen) to the test reports and went on (customise) against advice — hitting the date now meant (cut) the final rehearsal. Nobody meant (endanger) the launch; nobody remembers (approve) the shortcut either. The company deeply regrets (compress) that final phase — and we regret (report) that the recovery will take two quarters.
to clean · piloting · listening · customising · cutting · to endanger · approving · compressing · to report
Nine choices, and every one changes what happened. Project English is precision English.
Take the patterns into the Speak tab — Task B's answer will be audited for them.
A note on the record: figures are rounded from public reporting and court filings; several settlements are confidential; failure-rate statistics vary by definition ("challenged" is doing heavy work in most of them); and every named company here has also done many things well — the catalogue collects their worst days, not their character.
All of it out loud, against the clock — and mind your verb patterns: in this world, stopped testing and stopped to test are different incident reports.
Your company is approving its own system replacement. Present the case as the pre-mortem: what these projects are → the Halloween with no chocolate → the catalogue and its three sins → the one company that pulled the plug → the fork: change the software or change the company → the invisible successes → your three non-negotiable conditions.
Use at least three meaning-changing verb patterns and five key terms (ERP, go-live, customisation, migration, legacy system, rollback, compress, fulfil, scope creep, pull the plug).
You are the programme director, four weeks from go-live. Testing has found serious defects; moving the date triggers contract penalties and a furious board. The CEO asks, in front of everyone: "Every project has bugs. Ours has a deadline. Are you telling me you can't deliver — or that you won't?"
Answer properly: refuse the false binary, translate the defects into business consequences (which orders, whose payroll), state what going live now would mean — with precise verb patterns — and give the decision you are formally recommending. Then compress it to ninety seconds.
The collision in one room: a department head insists "we've always done it this way"; the system standard says otherwise. As the analyst in the middle, run the meeting — make the department's real requirement visible, price the customisation honestly (forever, not once), and land a recommendation both sides can repeat upstairs.
Prefer a ready-made collision? Take one of these: