Why game design tests model-view separation in LLD - Scalability Evidence

Scalability Analysis - Why game design tests model-view separation

Growth Table: User Scale Impact on Model-View Separation in Game Design

Users	Model Layer	View Layer	Interaction	Challenges
100 users	Simple game state, few objects	Basic rendering, low frame updates	Direct updates, minimal lag	Low complexity, easy sync
10,000 users	More game entities, complex state	Multiple views, UI updates	Increased update frequency, latency concerns	Need clear separation to avoid UI lag
1,000,000 users	Distributed state management, sharding	Dynamic rendering, personalized views	High concurrency, asynchronous updates	Model-view decoupling critical for performance
100,000,000 users	Massive distributed systems, microservices	Global UI scaling, CDN for assets	Eventual consistency, delayed updates	Strict separation needed for scalability and maintainability

First Bottleneck

As user count grows, the model layer managing game state becomes the first bottleneck. This is because it must handle many simultaneous updates and maintain consistency. Without clear separation, the view layer (rendering and UI) can be blocked or slowed by heavy model processing, causing lag and poor user experience.

Scaling Solutions

• Horizontal scaling: Split model processing across multiple servers or shards to distribute load.
• Asynchronous updates: Decouple view updates from model changes using event queues or messaging.
• Caching: Cache frequently accessed game state data to reduce database hits.
• Microservices: Separate model and view services to independently scale and deploy.
• Client-side prediction: Let the view predict changes to reduce perceived latency.

Back-of-Envelope Cost Analysis

• At 1M users, assuming each user sends 1 update per second, model layer handles ~1M QPS.
• Database and state storage must support high write throughput; consider sharding.
• Network bandwidth must support frequent state syncs; use compression and delta updates.
• View servers need GPU/CPU resources for rendering; scale horizontally.

Interview Tip

Start by explaining what model-view separation means in game design. Then discuss how scaling user numbers affects each layer differently. Identify the first bottleneck clearly and propose targeted solutions. Use real numbers to show understanding of system limits and justify your approach.

Self Check

Your game model database handles 1000 QPS. Traffic grows 10x to 10,000 QPS. What do you do first?

Answer: Add read replicas and implement caching to reduce database load, and consider sharding the model data to distribute writes. This prevents the model layer from becoming a bottleneck and keeps the view responsive.

Key Result

Model-view separation in game design is essential because as user count grows, the model layer managing game state becomes the first bottleneck. Clear separation allows independent scaling and prevents UI lag.