Migration Guide
AWS GameLift Is Costing You More Than You Think. Here's How Studios Get Off It.
Per-core cost, AWS lock-in, and fleet-configuration complexity are the three reasons studios migrate. None of them require a deadline — just a decision.
Updated July 1, 2026
Running on AWS credits?
Gameye can act as your orchestration layer now, routing sessions to AWS while your credits last. When they expire, you flip the underlying infrastructure to Gameye's bare metal and cloud — same API, same code, zero downtime. The studios that scramble are the ones who wake up to a full GameLift bill the month after credits run out and have to migrate under pressure.
AWS GameLift is a capable service. It's also one of the most expensive ways to run dedicated game servers at scale — its virtualised cores do less work per vCPU than high-clock bare metal (so you rent more of them), a proprietary server SDK embeds AWS deeply into your game code, and the fleet management model requires ongoing DevOps attention even when nothing is wrong.
Studios migrating to Gameye aren't doing it because of a shutdown notice. They're doing it because the math stopped working — or because they want to fix it before it does.
- GameLift Server SDK (
InitSDK,ProcessReady,OnStartGameSession) - Session allocation call (
CreateGameSession→ GameyePOST /session) - Fleet and build management (GameLift console → Gameye API or Admin)
- FlexMatch — keep it in STANDALONE mode, or replace with Nakama, Pragma, or any HTTP matchmaker
- IAM roles and CloudFormation templates for GameLift resources
- Server packaging (zip upload → Docker image)
- Authoritative game server logic
- Networking model and netcode
- Client connection flow (still receives IP + port)
- Game binary (repackaged, not rewritten)
- Matchmaking rules and player grouping logic
- Player-facing behaviour
Where does GameLift's cost actually come from?
The per-vCPU rate is visible. What's not: GameLift's virtualised cores do less game-server work per vCPU, so you rent more of them — and if you're on older fleets, in China, or self-hosting on EC2, egress still stacks on top.
A game-server tick is single-threaded, so clock speed sets how many players fit on a core. GameLift's mainstream instances run 2.8–3.9 GHz virtualised cores (on c7i a vCPU is half a physical core), while Gameye runs 5 GHz dedicated bare metal — so the same concurrency needs fewer cores. Egress used to be the headline cost, but AWS made bandwidth free on managed GameLift gen-6+ instances in 2026; it still applies on gen-5/older fleets, in China, or if you self-host on EC2.
GameLift requires configuring fleets, build uploads, scaling policies, fleet aliases, and EC2 instance types — and revisiting that configuration when demand patterns change. That's not a one-time setup; it's ongoing DevOps work. Studios routinely over-provision to avoid cold-start delays, which means paying for idle capacity around the clock.
All GameLift sessions run on AWS. A regional outage takes your game down with no automatic failover. Gameye routes sessions across multiple bare metal and cloud providers — if one has an incident, sessions shift automatically.
GameLift's Server SDK embeds AWS-specific session lifecycle management into your dedicated server binary. Every build carries it. Removing it isn't hard, but it's the kind of technical debt that accumulates if you plan to migrate later rather than now.
| Cost line | AWS GameLift | Gameye |
|---|---|---|
| Compute | EC2 instance-hours (gen-6/7 ~$0.034–0.051/vCPU-hr) | $0.07/vCPU/hr ($0.027 reserved) |
| Cores per player | More — 2.8–3.9 GHz virtual cores (c7i vCPU = ½ core) | Fewer — 5 GHz dedicated bare metal |
| Egress | Free on gen-6+; else ~$0.09/GB (gen-5/older, China, self-hosted EC2) | Included — every provider & region |
Rates, not a monthly total — your real number depends on concurrency, hours, and tick rate. The structural difference: a 5 GHz Gameye core hosts more players than a 2.8–3.9 GHz GameLift vCPU, so you rent fewer cores, and bandwidth is always included. Model your own load in the cost calculator, or see the full per-core cost model.
What does the migration path look like?
GameLift uses build uploads — a zipped server binary uploaded to S3. Gameye runs Docker images. If you're not already building your dedicated server as a Docker image, this is the main new step — and it's a one-time change that applies to any future infrastructure you use.
Your Unreal or Unity headless server build produces a binary. A Dockerfile wraps that binary and its runtime dependencies into a portable image, which you push to a container registry (Docker Hub, AWS ECR, or any OCI-compatible registry). Gameye pulls the image when starting sessions.
Strip the following from your dedicated server build:
Aws.GameLift.Server.GameLiftServerAPI.InitSDK()— SDK initialisationProcessReady()— readiness signal to GameLift fleetOnStartGameSessioncallback — session start handlerOnProcessTerminatecallback — graceful shutdown handlerActivateGameSession()andTerminateGameSession()calls
Replace them with nothing proprietary. Gameye determines server readiness through a configurable health check — typically a port check or a lightweight HTTP endpoint your server exposes when it's ready to accept players. Your server just needs to listen on the port specified in the session metadata.
Wherever your backend calls CreateGameSession or polls DescribeGameSessions, replace it with a single POST request to Gameye's Session API:
// Create game session → poll for ACTIVE status → describe for IP/port // Multiple API calls, status polling, SDK dependency CreateGameSession(request) → DescribeGameSessions → GetConnectionInfo
POST /session
{ "image": "your-image:tag", "region": "eu-west", "metadata": {...} }
→ 200 OK: { "ip": "1.2.3.4", "port": 7777 } IP and port are returned in the same response — no polling loop, no status management.
If you're using FlexMatch, the fastest path is STANDALONE mode — a lightweight Lambda function receives the MatchmakingSucceeded event and calls the Gameye Session API instead of GameLift. Your matchmaking rules, rule sets, and ticket logic are completely unchanged. Full guide here →
If FlexMatch isn't viable, or you're evaluating alternatives, Gameye connects to any HTTP-capable matchmaker: Unity Matchmaker, Nakama, Pragma Engine, PlayFab, OpenMatch, or a custom backend. Your matchmaking logic (player grouping, skill brackets, region preferences) transfers directly — you're only replacing the session allocation call.
Run GameLift and Gameye in parallel. Route one region's traffic to Gameye, validate session start time, stability, and cost over a week, then shift region by region. No hard cutover required. If anything is off, traffic rolls back without players noticing.
Most studios complete end-to-end validation within two weeks. The actual traffic shift is a configuration change.
What doesn't change: Your authoritative server logic, networking model, client connection flow, player-facing behaviour, and any matchmaking rules. The migration scope is the infrastructure layer — not your game.
Can you use your AWS credits during migration?
Many studios on AWS Activate, Y Combinator credits, or investor-sourced cloud agreements are running GameLift at effectively zero marginal cost today. That's not a reason to wait — it's a reason to start now.
Your backend calls Gameye's Session API. Gameye routes sessions to AWS infrastructure while you're still on credits. You get Gameye's sub-second allocation and fleet management immediately — credits still cover the underlying AWS compute.
Change one configuration — the infrastructure provider Gameye routes to. Sessions now run on Gameye's bare metal and cloud providers. Your backend API call hasn't changed. Your players see nothing change.
$0.07/vCPU/hr, no egress fees. You avoided an emergency migration and your players never experienced a disruption.
The studios that scramble are the ones who discover the full GameLift bill the month after credits run out, with a live game and players expecting uptime. Starting the integration now turns that into a planned transition.
How do the platforms compare side by side?
| AWS GameLift | Gameye | |
|---|---|---|
| CPU / clock | ~2.8–3.9 GHz virtual cores | 5 GHz dedicated bare metal |
| Egress / bandwidth fees | Free on gen-6+; else $0.08–$0.09/GB | None — every provider & region |
| Compute pricing | EC2 on-demand + management fees | $0.07/vCPU/hr flat |
| Session start time | Seconds–minutes (fleet dependent) | ~0.5s average |
| Provider coverage | AWS only | Bare metal + multi-cloud |
| Provider failover | None — single provider | Automatic, multi-provider |
| Matchmaker | FlexMatch (GameLift-coupled) | FlexMatch STANDALONE, Nakama, Pragma, or any HTTP matchmaker |
| Fleet management | Manual — EC2 types, aliases, policies | Managed — API driven |
| IAM / infra complexity | High — IAM roles, CloudFormation | None |
| Proprietary server SDK | Required — GameLift Server SDK | None — standard port/health check |
| Trial access | AWS account setup required | Self-serve |
| Works during AWS credit period | Yes | Yes — orchestrates AWS or own infra |
Why do studios migrating from GameLift choose Gameye?
Gameye runs 5 GHz dedicated bare metal vs GameLift's 2.8–3.9 GHz virtual cores, so the same player count fits on fewer cores. And bandwidth is always included — GameLift's free egress is gen-6+ managed only; gen-5/older, China, or self-hosted EC2 still pay $0.08–$0.09/GB, which Gameye never charges.
Remove five GameLift SDK calls from your server. Replace them with nothing proprietary. Gameye determines readiness through a standard health check — your server just needs to listen on a port. No SDK version updates to track, no AWS dependency in your binary.
Gameye starts sessions in ~0.5 seconds on average. No fleet pre-warming, no EC2 cold starts, no scaling policy lag. Players grouped by a matchmaker connect to a server that was already running and waiting.
Gameye routes sessions across bare metal and multiple cloud providers. If one has an incident, sessions shift automatically. You're not replacing AWS lock-in with Gameye lock-in — the same Docker image runs wherever Gameye schedules it.
FlexMatch, Nakama, OpenMatch, or a custom backend — Gameye's Session API is a single HTTP endpoint. Any system that can make a POST request can allocate a session. You don't replace your matchmaking logic; you replace the hosting call inside it.
Parallel-run by region. Validate Gameye on 10% of traffic before shifting the rest. No hard cutover. If you're on AWS credits, integrate Gameye now and flip the infrastructure when credits expire — same API, zero downtime.
Frequently asked questions
Do I need to rewrite my game server to migrate from GameLift?
No. Your authoritative game server logic, networking model, and client connection flow are unchanged. The migration scope is: remove the GameLift Server SDK from your server build, replace the session allocation call in your backend, and package your server as a Docker image if you haven't already. Your game binary and netcode stay the same.
Can I keep using FlexMatch if I move to Gameye?
Yes — and it's the recommended path if you already have FlexMatch matchmaking rules built. Use FlexMatch in STANDALONE mode: a Lambda function receives the MatchmakingSucceeded SNS/EventBridge event and calls the Gameye Session API instead of creating a GameLift game session. Your rule sets, ticket submission, and player attributes are unchanged. If FlexMatch isn't the right fit long-term, Gameye connects to Unity Matchmaker, Nakama, Pragma Engine, PlayFab, or any custom backend over standard HTTP.
How does Gameye handle server warm-up compared to GameLift fleet pre-warming?
GameLift requires you to pre-warm fleets — pre-allocating EC2 capacity and configuring scaling policies to have servers ready. Cold starts on un-warmed capacity can take minutes. Gameye maintains a dynamic warm buffer of pre-started containers that sessions are allocated from in ~0.5 seconds. There's no fleet to configure or warm — you pay for sessions when they run, not for reserved capacity sitting idle.
What replaces the GameLift Server SDK in my dedicated server?
Nothing proprietary. Remove InitSDK, ProcessReady, OnStartGameSession, and OnProcessTerminate from your server code. Gameye determines server readiness through a configurable health check — typically a port check or a lightweight HTTP endpoint. Your server just needs to listen on the port specified in the session metadata. No Gameye-specific SDK is required on the server.
How much do studios typically save migrating from GameLift to Gameye?
Savings come from per-core efficiency (5 GHz bare metal hosts more players per core than GameLift's 2.8–3.9 GHz virtual cores) plus included bandwidth. AWS made egress free on managed GameLift gen-6+ instances in 2026, but on gen-5/older fleets, in China, or self-hosting on EC2, a game running 1,000 concurrent 8-player sessions at 20 KB/s still generates over $1,000/month in egress — and that line never exists on Gameye. Model your own numbers →
I'm still on AWS credits and GameLift is essentially free — why migrate now?
Because by the time your credits expire, you'll want the migration already done. GameLift's full cost hits in full the month credits run out. Studios that integrate Gameye while credits are active use that period to validate performance and get comfortable with the platform. Gameye can route sessions to AWS infrastructure during the credit period, then shift to Gameye's bare metal and cloud when credits expire — same API, same code, zero downtime for players.
Ready to cut your GameLift bill?
Start a Developer Trial, push your Docker image, and run your first Gameye session. Most studios complete parallel testing within two weeks — with or without a GameLift deadline.