How to Approach a System Design Problem: A Step-by-Step Guide for Developers

Mintrovia System Design in Practice Part 2

Part 2 of 12 · System Design in Practice

Learning how to approach a system design problem is an essential skill for software developers preparing for system design interviews and building scalable applications. Instead of immediately choosing databases, servers, or technologies, start by understanding the requirements and defining a structured design process.

Have you ever been asked to design a system—such as a URL shortener, an online store, or a chat application—and felt unsure where to begin? This guide walks through a practical, repeatable system design approach using a URL shortener as an example—from requirement clarification and traffic estimation to architecture, bottlenecks, and trade-offs.

Use the steps as a framework, not a rigid checklist. The right design depends on the system’s requirements, expected scale, constraints, and priorities.

Why Do We Need a Structured Approach?

System design problems are usually open-ended. There may be several valid solutions, and the best choice depends on requirements, traffic, budget, and expected growth.

A structured approach helps you understand what the system must do, estimate scale, identify APIs and data, explain architecture, and spot bottlenecks and trade-offs.

Step 1: Clarify the Requirements

Before drawing the architecture, clarify what the system should do. Requirements are commonly grouped into two categories.

Functional requirements

These describe the features the system must provide. For our URL shortener:

  • A user can submit a long URL and receive a short URL.
  • Visiting the short URL redirects to the original URL.
  • Optionally, a short URL can have an expiration date.

Non-functional requirements

These describe how well the system should work.

  • Availability: Short links should work reliably.
  • Performance: Redirects should happen quickly.
  • Scalability: The system should handle increasing traffic.
  • Durability: Created links should not be lost unexpectedly.

State your assumptions and ask questions when requirements are unclear. You do not need to solve every possible feature in the first version.

Step 2: Estimate the Traffic

Estimation helps us understand the approximate scale. Perfect numbers are not required; reasonable assumptions help guide the design.

  • 10 million monthly active users
  • Each user creates 2 short URLs per month
  • Each created URL receives about 10 redirects
  • Peak traffic is assumed to be 10 times average traffic

URL creation traffic

10 million users × 2 URLs per month = 20 million new URLs per month.

Using a 30-day month, this is roughly 8 URL-creation requests per second on average. With our assumed 10× peak factor, the peak is about 80 requests per second.

Redirect traffic

20 million created URLs × 10 redirects each = 200 million redirects per month.

That is approximately 77 redirect requests per second on average, or about 770–800 requests per second at the assumed peak.

These figures are illustrative assumptions for learning—not measured traffic data from a real URL-shortening service.

Step 3: Define the APIs

APIs describe how clients communicate with our system. For a basic URL shortener, start with two endpoints.

Create a short URL

Endpoint: POST /api/urls

{
  "longUrl": "https://example.com/articles/system-design"
}

Example response:

{
  "shortUrl": "https://mintrovia.in/abc123"
}

Redirect to the original URL

Endpoint: GET /abc123

The server looks up short code abc123 and redirects the visitor to the original URL. A temporary redirect commonly uses HTTP 302. A permanent redirect may use 301; choose the status code based on whether the redirect is intended to be temporary or permanent.

Step 4: Design the Data Model

We need to store the mapping between each short code and its original URL. A simple record could look like this:

{
  "id": "unique-record-id",
  "shortCode": "abc123",
  "originalUrl": "https://example.com/articles/system-design",
  "createdAt": "2026-10-30T10:00:00Z",
  "expiresAt": null
}

The shortCode must be unique. The database should enforce this with a unique constraint or index. The expiresAt field is optional and can support expiring links.

Focus on the data the system needs. The exact database choice can be made after considering access patterns, scale, and consistency requirements.

Step 5: Draw the High-Level Architecture

A basic design could include a load balancer, application servers, a cache, and a database.

                 +--------------+
                 |    Users     |
                 +------+-------+
                        |
                 +------v-------+
                 | Load Balancer|
                 +------+-------+
                        |
              +---------+---------+
              |         |         |
          +---v---+ +---v---+ +---v---+
          | App 1 | | App 2 | | App 3 |
          +---+---+ +---+---+ +---+---+
              +---------+---------+
                        |
                 +------v-------+
                 |    Cache     |
                 +------+-------+
                        | Cache miss
                 +------v-------+
                 |   Database   |
                 +--------------+

Request flow:

  1. A user opens a short URL.
  2. The load balancer forwards the request to an application server.
  3. The application checks the cache for the short code.
  4. If cached, the original URL is returned quickly.
  5. On a cache miss, the application reads the mapping from the database and may cache it.
  6. The application redirects the user to the original URL.

This is a high-level design. Cache eviction, database replication, and short-code generation can be explored as the system evolves.

Step 6: Identify Potential Bottlenecks

  • Database read load: Popular links may be requested repeatedly. Caching can reduce database reads.
  • Application capacity: If traffic exceeds app-server capacity, more instances may be needed.
  • Short-code generation: Code generation must avoid collisions and ensure uniqueness.
  • Database availability: Database outages can cause cache misses to fail. Replication and recovery strategies may help.
  • Cache behavior: Cache effectiveness depends on expiry policies and which data remains cached.

Do not add complex solutions to every possible problem immediately. Identify the bottleneck most likely to matter for your requirements.

Step 7: Discuss Trade-offs

  • Add a cache: Redirects may become faster and database load may decrease, but invalidation and memory usage become concerns.
  • Add application servers: Capacity increases, but deployment and monitoring become more involved.
  • Use database replicas: Read capacity may improve, but replication lag can delay visibility of new data.
  • Collect click analytics: Analytics provide insight, but recording clicks adds work and storage requirements.

There is no single architecture that is best for every situation. Explain why a choice fits the requirements and what you give up in return.

Common Beginner Mistakes

  • Choosing technologies before understanding requirements.
  • Skipping traffic estimates.
  • Adding too many components to a simple first version.
  • Ignoring failure cases, such as database outages or cache misses.
  • Presenting a design as perfect instead of explaining trade-offs.

A Simple System Design Interview Checklist

  1. Clarify functional requirements.
  2. Define non-functional requirements.
  3. State assumptions and estimate traffic.
  4. Identify the main APIs.
  5. Design the data model.
  6. Draw the high-level architecture.
  7. Walk through the request flow.
  8. Identify bottlenecks and failure scenarios.
  9. Discuss improvements and trade-offs.
  10. Summarize the design and its limitations.

Practice These Questions

  • How would you design a URL shortener for a small application?
  • What changes would you make if redirect traffic increased significantly?
  • What would happen if the cache or database became unavailable?

Frequently Asked Questions

What is the first step in a system design problem?

Start by clarifying the functional and non-functional requirements. Understand what the system must do, how well it must work, and which constraints matter before choosing technologies.

Why is traffic estimation important in system design?

Traffic estimation provides an approximate view of request volume and peak load. These estimates help guide decisions about application capacity, data storage, caching, and potential bottlenecks.

What are the main steps of high-level system design?

A practical process is to clarify requirements, estimate traffic, define APIs, design the data model, draw the high-level architecture, identify bottlenecks, and discuss trade-offs.

Do I need to choose a database at the beginning?

Not necessarily. First understand the requirements and data access patterns. Then compare database options against the system’s scale, consistency needs, and constraints.

Conclusion

When approaching a system design problem, do not begin by searching for the “perfect” architecture. Start by understanding the requirements, estimating the scale, defining APIs and data, and then drawing a simple design.

Once the basic system is clear, identify bottlenecks and improve it step by step. This process makes your design easier to explain, evaluate, and evolve.

In the next part of System Design in Practice, we will explore Scalability Basics—including vertical scaling, horizontal scaling, and how stateless application servers help a system grow.

What is the first thing you usually do when you receive a system design problem? Share your approach in the comments.


System Design in Practice — 12-Part Series

Part 1: What Is System Design? A Simple Introduction for Developers

Part 2: How to Approach a System Design Problem

Part 3: Scalability Basics — Vertical vs. Horizontal Scaling (coming next)

Enjoyed this article?

If this article helped you learn something or solve a problem, you can support Mintrovia and help us continue creating free programming content.

Support Mintrovia