#system design

Introduction

Many software developers start their careers by learning programming languages, frameworks, and databases. While these technical skills are important, they often represent only the first stage of software engineering. As developers progress in their careers, they are expected to design systems, solve architectural challenges, and make technical decisions that impact entire applications.

This transition requires a solid understanding of system design. Unfortunately, many developers find system design intimidating because it involves concepts such as scalability, distributed systems, object-oriented design, databases, caching, and architecture patterns.

The good news is that system design can be learned systematically. By following a structured roadmap, beginners can gradually progress from fundamental concepts to advanced architectural thinking. A System Design Course Focused on LLD and HLD provides this journey, helping learners develop both design and problem-solving skills.

Stage 1: Building Programming Foundations

Before learning system design, developers should understand:

Programming fundamentals

Object-oriented programming

Data structures

Algorithms

Database basics

These topics provide the technical foundation required for advanced design concepts.

Stage 2: Understanding Object-Oriented Design

Object-oriented design introduces principles such as:

Encapsulation

Inheritance

Polymorphism

Abstraction

These concepts help developers organize software into reusable and maintainable components.

Stage 3: Learning Low-Level Design

Low-Level Design focuses on:

Class design

UML diagrams

Object interactions

Design patterns

Component responsibilities

LLD helps developers create clean and structured software modules.

Stage 4: Understanding High-Level Design

Once LLD concepts are clear, learners can move to HLD topics such as:

System architecture

Service communication

Database selection

Scalability planning

Infrastructure design

These concepts help developers think beyond individual classes and modules.

Stage 5: Studying Scalability Principles

Modern applications must support large numbers of users.

Important scalability concepts include:

Load balancing

Caching

Database sharding

Replication

Asynchronous processing

Understanding these topics helps developers build high-performance systems.

Stage 6: Exploring Distributed Systems

Distributed systems introduce advanced concepts such as:

Fault tolerance

Event-driven architecture

Service discovery

Distributed databases

Consistency models

These skills are increasingly important in cloud-native applications.

Stage 7: Real-World System Design Problems

Practical learning often includes designing:

Social media platforms

E-commerce systems

Ride-sharing applications

Messaging services

Video streaming platforms

These exercises help learners apply theoretical concepts.

Benefits of a Structured Learning Path

A step-by-step approach helps students:

Avoid information overload

Build confidence gradually

Understand complex topics clearly

Develop practical problem-solving skills

Structured learning is often more effective than random self-study.

Career Growth Opportunities

System design expertise supports advancement into roles such as:

Senior Software Engineer

Technical Lead

Software Architect

Solution Architect

Engineering Manager

These positions require strong design and architectural thinking.

Conclusion

System design is not a skill that develops overnight. It requires a structured learning journey that starts with programming fundamentals and progresses through design, architecture, scalability, and distributed systems.

To me transforming the food system is possible through a combination of government+grassroot+individual actions.

In any competitive game, there are two core elements: execution and resources. The players must manage both of these elements in order to meet victory conditions and win the game. Execution encompasses the player's decision-making process and means to enact those decisions. This covers deciding which buttons to push and when those buttons are pushed. Resources entail things in game that are expended for game results - health, super meter, mana, ammunition, abilities with cooldowns, and so on.

Let's examine how a competitive game actually breaks down. Competitive games are not evenly distributed across the entire period of play - it isn't like a race where each player can move at only one speed and the winner is determined from the very beginning by that speed. In a fighting game, for example, there are different game states that affect what happens. When a player lands a hit, the attacking player can perform a combo to deal a chunk of damage to the defending player. The amount of damage dealt is determined by the attacker's Execution and expenditure of Resources. As such, the life bar is mostly an abstraction of how close a player is to losing. The reality is that good players can deplete the life bar in some limited number of combos (e.g. three combos will kill a player), so the game becomes about the players landing those three initial hits.

Once we understand that competitive game play is about using execution to convert resources into a new game state, things start making more sense. The design of the game determines when these resources are introduced and how large an effect those resources have. In League, the jungle creeps are early game resources. Baron Nashor is a late game resource. We should start to recognize that each of these elements represents a swing in the way the game's likely results - using a single Monopoly card in Settlers of Catan statistically increases your chances of winning by around 17%. The size of the effect must be sufficiently large, especially near the late game portion of the match.

This means that whoever has the advantage continues to hold that advantage, but it doesn't mean that the losing team is out. Because the resource + execution swing in game effect increases in size as the game progresses from early to mid to late game, judicious late game swings can make up for early game disadvantage. If a player can deal 40% health with a fully charged super move, it doesn't matter whether their opponent has 39% health or 1% health - landing the super move will still be lethal. The size of that chunk makes that player a reasonable threat, even when behind in game state. This is how we keep competitive games exciting while still maintaining advantage - the advantages earned shouldn't be so overwhelming that a player cannot reasonably come from behind, but should also not be meaningless over the course of the game. The size of the advantage swing should start low and increase over the course of the game, leading to more exciting late game play.

[Join us on Discord] and/or [Support us on Patreon]

Got a burning question you want answered?

Short questions: Ask a Game Dev on Twitter

Short questions: Ask a Game Dev on BlueSky

Long questions: Ask a Game Dev on Tumblr

There is a highly specific, modern brand of anxiety that occurs when you open a collaborative workspace application. It starts with the rows of flashing red notification badges, moves into the endless sea of inline comments, and peaks when you realize your entire day is being tracked, logged, and broadcasted to your colleagues in real-time.

Tools that were originally marketed as elegant solutions to liberate us from the chaotic mess of corporate email have slowly mutated into digital surveillance engines. They don't just organize our labor, they demand our constant, unblinking presence.

The reason we feel so completely drained by these platforms isn't just a cultural issue of poor workplace boundaries. It is an engineering problem. We are experiencing the psychological side effects of computational maximalism: modern productivity tools are built on rigid, synchronous backends that treat every single emoji reaction like a mission-critical system crisis.

The Machine in the Background: Synchronous Overload

In an ideal software ecosystem, your tools should operate quietly in the background. But traditional software design relies heavily on point-to-point, synchronous execution channels.

When a manager modifies a single card on a shared project dashboard, the underlying application engine doesn't just save that text. In a tightly coupled framework, that single click forces the web server thread to stall while it sequentially alerts the database, updates global analytical readouts, pushes live UI updates to every connected team member, and triggers automated external API pings.

Because everything is tied to a single execution chain, a performance drop or temporary crash in any minor auxiliary feature doesn't just cause a silent background delay, it freezes your entire user interface.

Under peak operational traffic, these open, blocked threads completely wipe out server connection pools. The corporate platform's cloud infrastructure panics, automatically spinning up more virtual machine instances to host what are essentially frozen, idle connection loops. You are paying a massive premium for empty infrastructure weight simply because your software components refuse to operate independently.

Uncoupling the Workspace Architecture

To restore performance sanity and mental clarity to digital workspaces, systems architects enforce strict separation between user actions and downstream notifications. This structural balance is achieved by implementing a decoupled, event-driven architecture.

By placing an independent, asynchronous message streaming broker (such as Apache Kafka or AWS EventBridge) as a central orchestration layer, individual application modules run as autonomous nodes.

Total Blast Radius Isolation: When a team member posts an update or changes a project deadline, the main application registers the event, hands it to the message broker, and immediately frees the client thread within milliseconds. The user interface stays fast, and the massive data parsing is offloaded safely.

Granular System Scaling: Background notification dispatches are pulled from the broker queue by isolated background workers. If your automated reminders experience a massive traffic spike at 9:00 AM on a Monday, you scale only those minor worker containers independently based on queue depth, protecting your infrastructure budget.

Perimeter Privacy Controls: A decoupled backend engineering pipeline establishes a secure boundary. Before streaming workspace metrics or user data across networks to external analytics software, the perimeter gateway can automatically run data-masking scripts to cryptographically hash or scrub sensitive records, handling global compliance mandates natively.

Moving Beyond the Software hiring Trap

When an enterprise platform begins to stutter under its own weight, the default corporate reaction is to throw headcount at the problem. Management launches an aggressive recruitment drive, loading up the engineering payroll with additional mid-level hires.

But adding more developers to a tangled, co-dependent codebase creates severe coordination friction. It results in a messy patchwork of conflicting updates that makes the application engine even more fragile.

True operational velocity is recovered by bringing senior, high-level perspective to system design. This is why scaling digital platforms utilize a strategic technical team extension or consult an experienced fractional CTO. By embedding specialized systems architects to audit active data pipelines and deploy production-grade backends, businesses can build a clean, modular workspace.

When you introduce asynchronous space into an architecture, you give your engineering team the structural freedom to ship new features with maximum velocity, absolute stability, and complete peace of mind.

The Workspace Resiliency Audit:

Test System Modularity: Can your development team deploy an update to your internal notification engine without running the structural risk of stalling your core database or task-tracking layers?

Audit Your Downtime Risk: If a third-party analytical integration encounters a brief lag right now, does your application possess an isolated boundary layer to block the failure before it freezes your primary user interface?

The concept of damage over time can only exist in a game where combat [Time To Kill] is fairly long. A player can only really do damage over time if the thing she's damaging actually lives long enough for the damage occur over time. If the foe dies within seconds or on the first tick of the damage over time, there really wasn't much damage over time done - it was really just a delayed hit. Having DoT as a role means there must actually be enough time that passes for it to actually shine.

There are certainly adjacent gameplay roles that synergize well with Damage over Time as a playstyle - debuffs, area-of-effect damage, vampiric healing, etc. which can lend some more interesting player choices. But none of these require damage over time as a foundation; we can also easily distribute such things through direct damage or other means as well. We can attach such things to damage over time to make it more compelling, but that doesn't necessarily solve our core problem.

Damage over time also isn't particularly interesting as gameplay. There aren't many interesting choices to be made when doing it, so players really just end up figuring out what ability rotation they must use in order to keep all of their DoTs on the target based on the durations of each one. This is a solvable problem and isn't particularly fun or interesting to solve or to play after it's been solved. There must be more interesting choices that a player must make as she plays that aren't a solvable problem.

All this said, it doesn't mean these problems can't be solved but that they are difficult to address. This brings us to the real decision here - do we really need to offer damage over time to players as an archetype in our game? If we as designers don't have a compelling case for it in our game, we should probably cut it to make room for another, more compelling player option. This is what you've been observing - most designers have recognized that the play style isn't particularly compelling, so newer games have mostly chosen to retire it. It's actually fairly similar to how there aren't as many games with dedicated healer gameplay roles anymore either, and for similar reason.

[Join us on Discord] and/or [Support us on Patreon]

Got a burning question you want answered?

Short questions: Ask a Game Dev on Twitter

Short questions: Ask a Game Dev on BlueSky

Long questions: Ask a Game Dev on Tumblr

We don't really have hard limits per se, but we have guidelines we try to follow. What you're talking about is a power curve which, in game design, describes the way that game elements grow in power over the course of the game's advancement systems. It is rare for a game to have items that are always obtainable from start to finish; usually there is some sort of progression from early game to mid game to elder game with growth in power along the way. The amount of growth and amount of resulting power is usually some sort of math formula, with small independent tweaks here and there to increase interest and fun. Usually this is a formula that takes some sort of resource cost or requirement (e.g. level, mana cost, gold cost, drawback, etc.) and converts it into some sort of desired result (damage, stat boost, good effect, etc.).

System designers take the costs and the desired results and create a formula to calculate one from the other, based on how we want the items at that power level to play. As an example, in Hearthstone minions that cost one mana have a rough ceiling of some established power. Minions that cost two mana have a higher power ceiling, minions that cost three mana have even higher, and so on and so forth. This is our baseline power curve - the guidelines that we use to generate our first pass for stuff. We establish a band at each cost for acceptable power - a low end and a high end, so that we have a means of measuring items that are too strong for their cost and items that are too weak for their cost. The floor is typically pretty low, really weak items generally don't cause gameplay problems like overly powerful items can.

We then add in modifiers like rarity (e.g. a three-cost legendary minion is better than a three-cost common minion) to adjust the power level of the individual items. We can add in interesting procs, beneficial effects, drawbacks, or whatever at this point. Each of these benefits or drawbacks has a power budget associated with it we use to determine its position within the power band. We can adjust these budgets to make certain options better or worse at our discretion, with the goal of staying within the acceptable power level band.

We then playtest our work to see how our numbers and power levels actually feel. We take our observations, iterate and adjust the numbers, and then playtest again, repeating the cycle until we get our desired play experience at each power step and level.

[Join us on Discord] and/or [Support us on Patreon]

Got a burning question you want answered?

Short questions: Ask a Game Dev on Twitter

Short questions: Ask a Game Dev on BlueSky

Long questions: Ask a Game Dev on Tumblr