Skip to content

Gambling · 500+ applications across several data centres · under NDA

Published · 5 min read

Moving more than 500 applications to AWS, one at a time

An international betting platform had outgrown an on-premise estate spread across several data centres. More than 500 applications — a mix of monoliths on virtual machines and containerised services — had to reach AWS without a visible outage, against a calendar nobody on the project controlled: the traffic peaks arrive with the sporting fixtures.

The situation

The estate had grown the way estates grow: by addition. Monoliths on virtual machines beside containerised services, several physical data centres, and a load curve the hardware had stopped keeping up with.

Downtime was the binding constraint rather than the technical difficulty. A betting platform's busiest hour is scheduled by somebody else, and it is the same hour the business earns in — so each move had to be invisible to users and reversible while it was happening.

We were brought in alongside the client's own DevOps and IT groups: ordering the queue, choosing the strategy per application and doing the work, rather than handing over a plan for someone else to run.

Solution

01A landing zone before a single workload

Nothing moved until the account structure existed: separate Development, Pre-production and Production accounts, with access and security policy set at the boundary rather than per application.

This is the part that is tempting to skip under schedule pressure and the most expensive to retrofit. An account layout is a decision every later workload inherits whether or not anyone revisits it.

02A hybrid network, so the cutover was not also a bandwidth problem

AWS Direct Connect carried traffic between the data centres and the new accounts for the length of the programme. Moving the data over the public internet would have made every cutover window depend on a number nobody controls.

It also let an application run with its data on one side and its compute on the other for as long as it needed, which is what made moving one application at a time possible at all.

03One application at a time, least critical first

The queue was ordered by blast radius rather than by effort. The early moves were the ones where a mistake was survivable, so the pattern was found on those and not on the payment path.

Each application got its own strategy. Some were rehosted unchanged, which freed physical capacity fastest and brought the data-centre exit forward. Some were replatformed onto managed services where the change paid for itself within the programme rather than in principle.

04Retiring counted as progress

The inventory found that roughly 15% of the legacy applications were not worth moving: their function had been absorbed elsewhere, or nobody could name a user. Those were retired or replaced rather than lifted.

This is the cheapest work in any migration and the easiest to skip, because switching something off does not look like progress on a migration plan. It was counted as progress here, which is the only reason it happened at that scale.

05A proof of concept before the contested decisions

Where the right shape was genuinely arguable, a throwaway environment settled it: stand the option up, check it against the on-premise systems it had to interoperate with, then decide.

A proof of concept is slower than a decision taken in a meeting. It is also the reason there was no architecture reversal part-way through the programme.

06Canary cutovers, approved by somebody other than us

Traffic moved to the new infrastructure gradually rather than at a switch. That gave a window in which the new path could be watched under real load, and an exit that did not need a maintenance night.

Every stage was approved by the client's own security and architecture board before it ran. An outside team moving 500 applications through somebody else's estate should not be the only party deciding what is safe to do next.

Outcome

500+
applications moved, one at a time
15%
retired or replaced instead of moved
22%
ahead of the migration plan
Estate in cloud at the end
More than 80% of capacity
Cutover method
Canary, traffic shifted gradually
Approval
Client's security and architecture board, per stage
Network during the programme
AWS Direct Connect to the data centres

The plan was beaten by 22%, and more than 80% of the company's capacity now runs in the cloud. Peak load during live fixtures is absorbed by autoscaling rather than by hardware bought for the worst hour of the year, and a new environment is a provisioning step instead of a procurement one.

The client reports infrastructure costs down by roughly 80%, in the region of $800,000. That figure is theirs rather than ours: it covers the whole estate across the whole programme, and a large part of it is the applications that were retired rather than moved. We have not reconciled it the way we reconcile a saving in an audit, so it appears here with its basis attached rather than as a headline.

The remaining fraction stayed on-premise. That was a commercial decision rather than a technical one, and a migration case study that implies the data centres emptied completely would be describing a different programme.

Core tech

  • AWS
  • AWS Direct Connect
  • EC2
  • Amazon ECS
  • Amazon EKS
  • Amazon RDS
  • Amazon S3
  • AWS IAM
  • Terraform
  • Docker
  • Kubernetes
  • CloudWatch

Method

What makes this routine rather than risky

Nothing here is proprietary. This is the part that transfers to your estate whether or not you ever call us.

Order the queue by blast radius

The first applications to move are the ones where being wrong is cheap. The pattern gets found on those rather than on the path that takes money.

Decide the strategy per application, not per programme

Rehost, replatform, retire. A programme that picks one of the three up front is optimising for a tidy plan rather than for the estate it actually has.

Count retirement as progress

Roughly one application in seven did not need to exist. Finding that out is the cheapest work in a migration, and it only happens if somebody is allowed to report switching something off as a result.

Let the client's board hold the gate

Approval at each stage by a cross-functional security and architecture board is slower than proceeding. It is also what stops an external team being the sole judge of its own risk.

More

Other work

All case studies

B2B SaaS · two EKS clusters on AWS · under NDA

Making a savings number smaller

Detectors summed to a headline figure. Reconciling the overlaps between them removed roughly three quarters of it — and that is what made the remainder usable.

E-commerce · production EKS on AWS · under NDA

A storage bill grew 20× on a filesystem holding 8 GB

Daily spend started climbing in the same week a dozen database instances were shut down — so the bill should have been falling. The billing line said EFS. The cause was in node provisioning, two layers away.

E-commerce · 18 RDS PostgreSQL instances on AWS · under NDA

Consolidating 18 production databases into 5

A legacy account with one RDS instance per service, most idling at 2–10% CPU. The business would grant two maintenance windows of fifteen to twenty minutes, on separate days, for a payment-adjacent platform. Everything else had to happen under live traffic.

Gambling · several production databases on one server · under NDA

Splitting one database server into three

Several production PostgreSQL databases shared a single server, so one busy neighbour was everybody's problem. Split onto three dedicated RDS instances, grouped by what actually contended rather than by size.

Illustrative · managed Kubernetes on AWS

Three EKS versions upgraded without a maintenance window

A cluster two versions past its support window, moved forward across three minor releases with no scheduled downtime — rehearsed first, with the disruption budgets fixed before anything moved.

Illustrative · CI on a hosted runner fleet

A CI pipeline from 38 minutes to 9

Build and test times measured per step before anything was touched, then caches that actually hit, parallelism where the dependency graph allowed it, and the work that had been running on every commit for no reason.