CAP theorem
~11 minTwo data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
Prepare for game server interviews, from transport and the server tick to the services and fleets behind online play. Covers networking, concurrency, player data, messaging, and cloud match hosting.
9761 of 9761 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 9761 new. 0 cut, outside your plan.
In interviews for server-side game roles, the round that usually decides the outcome is the networking one. Around it sit a screen, a coding exercise in the language the studio's servers are written in, a behavioral interview and, for hires above junior, a system design conversation. Networking questions start from what a player sees. Movement stutters whenever a packet is lost: what does TCP's in-order delivery do to the updates queued behind the missing one, and why do fast-paced games send state over UDP while login stays on HTTP? A shot that looked like a hit was rejected: why does the server decide, how does prediction keep the client feeling instant, and what does lag compensation rewind? Concurrency questions sit on the tick, where every room's simulation, reads and snapshots share a fixed budget: what happens to the other rooms on a thread when one overruns? Design rounds take a service from around the game, such as matchmaking, a global leaderboard or a world split across machines. What separates levels is arithmetic and failure. Most candidates can say why UDP; a senior puts numbers on it, bytes per player per tick and players per core, and can say what a player loses when a match server dies mid-round, what was already persisted and how a reconnecting client finds the match again.
A game server is one process holding many players at once, so the plan opens on what that process is made of: [concurrency](/topics/found-concurrency), [memory management](/topics/found-memory-management), where an allocation burst or a collector pause lands inside a tick, and [serialization](/topics/found-serialization), because every update leaves the process as bytes. Paradigms and design come next, with [reactive streams](/topics/found-reactive-programming) among them for the client that cannot keep up with what the server sends, and the stretch ends on the [algorithms](/topics/found-dsa) a coding round is graded on. Then the plan goes onto the wire. [UDP](/topics/proto-udp) is read against TCP and its in-order delivery, [NAT](/topics/proto-nat) decides whether two players can reach each other directly, DNS steers a player toward a region, and one leaf of NTP, the [offset and delay arithmetic](/topics/proto-ntp-clock-offset-delay), is the calculation a client commonly borrows to line its clock up with the server's. HTTP and TLS sit one layer up for the login, store and patch traffic that does not need a game's own transport. The host follows, Linux processes and sockets and then the [profilers and tracers](/topics/os-tracing-diagnostics) that show where a tick's milliseconds went. Only with the wire and the host in place does the plan reach [the loop itself](/topics/game-engine-architecture-game-loop), the fixed timestep a simulation advances on, and then the channels a browser match uses instead of raw UDP: [WebSockets](/topics/proto-websockets), and [WebRTC](/topics/proto-webrtc) with its data channels and its ICE negotiation through NAT. The middle of the plan is the set of services around the match, built much as any backend builds them. Framework concepts and the API styles from REST to [gRPC](/topics/proto-grpc) carry login, matchmaking and store calls. Player data opens on [relational concepts](/topics/db-relational-concepts) and SQL, because a purchase and the inventory it changes need one transaction, before document and wide-column models take profiles and event history. Live state gets a module of its own: [in-memory stores](/topics/db-in-memory-concepts) hold sessions and presence, and their score-ordered sets are the usual shape of a leaderboard. Architecture, event-driven design and [broker operations](/topics/cloud-messaging-concepts) lead to [distributed systems](/topics/found-distributed-systems) and resilience patterns, the material a design round on matchmaking or a sharded world is argued in. The practice stretch is the one any server team expects, with a game server's edge in two places: [load tests](/topics/found-test-types-performance-workloads) shaped like a launch-night surge, and [DDoS mitigation](/topics/sec-network-defense-ddos), because a match server's open UDP port is an easy target for a flood. Git closes it. The plan then moves to where match servers run. Containers lead into [Kubernetes](/topics/cloud-kubernetes), where a pod holding a live match cannot be drained like a stateless replica, and cloud concepts add [regional placement](/topics/cloud-providers-concepts-footprint), since the region a match runs in sets a player's latency before any code does, plus serverless functions for event work around the game. Traffic routing, delivery pipelines and service levels finish operations. Coding with an AI assistant and the [behavioral round](/topics/found-behavioral) close the plan.
Coming from web backends, the middle of the plan is mostly revision; give the first weeks to transport, the host and the tick, where a web career leaves the fewest answers ready. A gameplay programmer is the mirror case, at home with the loop and the engine, and new to stores, brokers and fleets. Inside the network modules, game loops usually lean on UDP, NAT and region steering far more than on IP addressing, so the subnet arithmetic can wait for a second pass. With a week or two left, prune where the plan is widest, in the services and fleet stretches: importance raised to must know thins them most, and level cut to the band on the posting drops design questions written for a seniority you are not applying at. Head-of-line blocking is the transport answer most worth having seen, and months of preparation leave room to see it: run a small UDP server and client on one machine with artificial latency and packet loss between them, then send the same position updates over TCP and watch each lost packet hold back the updates after it. Each step of that experiment takes the next stretch of the plan, the protocols from the wire, sockets and tracers from the host, a fixed timestep from the loop, and by topics is the study order that hands them over in that sequence. Two subjects interviewers raise have no module here. Prediction, reconciliation and lag compensation have to be built from the transport, tick and concurrency material. The plan also teaches no general-purpose language, because studios write servers in several; the [C++](/roadmaps/cpp) and [C#](/roadmaps/csharp) roadmaps cover the two that engine-side servers use most. Rendering, physics and gameplay code inside the engine belong to the [Game Developer roadmap](/roadmaps/game-developer), the other half of the team a server developer works beside.
Two data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
In interviews for server-side game roles, the round that usually decides the outcome is the networking one. Around it sit a screen, a coding exercise in the language the studio's servers are written in, a behavioral interview and, for hires above junior, a system design conversation.
Networking questions start from what a player sees. Movement stutters whenever a packet is lost: what does TCP's in-order delivery do to the updates queued behind the missing one, and why do fast-paced games send state over UDP while login stays on HTTP? A shot that looked like a hit was rejected: why does the server decide, how does prediction keep the client feeling instant, and what does lag compensation rewind? Concurrency questions sit on the tick, where every room's simulation, reads and snapshots share a fixed budget: what happens to the other rooms on a thread when one overruns? Design rounds take a service from around the game, such as matchmaking, a global leaderboard or a world split across machines.
What separates levels is arithmetic and failure. Most candidates can say why UDP; a senior puts numbers on it, bytes per player per tick and players per core, and can say what a player loses when a match server dies mid-round, what was already persisted and how a reconnecting client finds the match again.
A game server is one process holding many players at once, so the plan opens on what that process is made of: concurrency, memory management, where an allocation burst or a collector pause lands inside a tick, and serialization, because every update leaves the process as bytes. Paradigms and design come next, with reactive streams among them for the client that cannot keep up with what the server sends, and the stretch ends on the algorithms a coding round is graded on.
Then the plan goes onto the wire. UDP is read against TCP and its in-order delivery, NAT decides whether two players can reach each other directly, DNS steers a player toward a region, and one leaf of NTP, the offset and delay arithmetic, is the calculation a client commonly borrows to line its clock up with the server's. HTTP and TLS sit one layer up for the login, store and patch traffic that does not need a game's own transport. The host follows, Linux processes and sockets and then the profilers and tracers that show where a tick's milliseconds went. Only with the wire and the host in place does the plan reach the loop itself, the fixed timestep a simulation advances on, and then the channels a browser match uses instead of raw UDP: WebSockets, and WebRTC with its data channels and its ICE negotiation through NAT.
The middle of the plan is the set of services around the match, built much as any backend builds them. Framework concepts and the API styles from REST to gRPC carry login, matchmaking and store calls. Player data opens on relational concepts and SQL, because a purchase and the inventory it changes need one transaction, before document and wide-column models take profiles and event history. Live state gets a module of its own: in-memory stores hold sessions and presence, and their score-ordered sets are the usual shape of a leaderboard. Architecture, event-driven design and broker operations lead to distributed systems and resilience patterns, the material a design round on matchmaking or a sharded world is argued in.
The practice stretch is the one any server team expects, with a game server's edge in two places: load tests shaped like a launch-night surge, and DDoS mitigation, because a match server's open UDP port is an easy target for a flood. Git closes it. The plan then moves to where match servers run. Containers lead into Kubernetes, where a pod holding a live match cannot be drained like a stateless replica, and cloud concepts add regional placement, since the region a match runs in sets a player's latency before any code does, plus serverless functions for event work around the game. Traffic routing, delivery pipelines and service levels finish operations. Coding with an AI assistant and the behavioral round close the plan.
Coming from web backends, the middle of the plan is mostly revision; give the first weeks to transport, the host and the tick, where a web career leaves the fewest answers ready. A gameplay programmer is the mirror case, at home with the loop and the engine, and new to stores, brokers and fleets. Inside the network modules, game loops usually lean on UDP, NAT and region steering far more than on IP addressing, so the subnet arithmetic can wait for a second pass.
With a week or two left, prune where the plan is widest, in the services and fleet stretches: importance raised to must know thins them most, and level cut to the band on the posting drops design questions written for a seniority you are not applying at. Head-of-line blocking is the transport answer most worth having seen, and months of preparation leave room to see it: run a small UDP server and client on one machine with artificial latency and packet loss between them, then send the same position updates over TCP and watch each lost packet hold back the updates after it. Each step of that experiment takes the next stretch of the plan, the protocols from the wire, sockets and tracers from the host, a fixed timestep from the loop, and by topics is the study order that hands them over in that sequence.
Two subjects interviewers raise have no module here. Prediction, reconciliation and lag compensation have to be built from the transport, tick and concurrency material. The plan also teaches no general-purpose language, because studios write servers in several; the C++ and C# roadmaps cover the two that engine-side servers use most. Rendering, physics and gameplay code inside the engine belong to the Game Developer roadmap, the other half of the team a server developer works beside.