Netflix-Scale System Design with AI: The Prompt-Led Approach

With AI tools like ChatGPT, Gemini, and Claude at our fingertips, being able to leverage AI to design systems is a new non-negotiable for all developers.

AI is good at handling tasks of a small scope. But for large-scale systems, we need a more structured approach involving:

• Breaking systems into smaller parts

• Editing and stitching together AI outputs

This involves a new skill set that I call Prompt-Led System Design, wherein you stay in charge, define the goals, and steer the architecture, while AI streamlines your process with tactical outputs and edge-case considerations.

Today I'll share how you can use Prompt-Led System Design to design large-scale systems like Netflix with AI.

We'll cover:

• What is Prompt-Led System Design?

• SCOPED, a six-step framework for designing systems like Netflix with AI

• A bonus hack I like to use for faster prototyping

Let's dive in.

Prompt-Led System Design#

Prompt-Led System Design involves leveraging AI throughout different stages of your design process, from requirement gathering to optimization. You prompt AI to help generate ideas, pressure-test assumptions, and explore edge cases.

With systems growing in size and complexity, Prompt-Led System Design offers a structured approach to manage this complexity more effectively. Combined with human creativity and judgment, AI's speed in processing information can help you unveil hidden insights and enable faster, more efficient System Design.

Let's see how it works with the SCOPED framework:

The SCOPED framework#

SCOPED is a step-by-step framework for designing systems assisted by AI. It involves the following steps:

• Set the vision (S): Clarify what you’re building and why it matters.

• Chunk the system (C): Break the big problem into smaller, well-defined parts.

• Optimize the subsystems (O): Refine subsystems to ensure correctness.

• Piece together outputs (P): Connect components into a working System Design.

• Evaluate and stress-test (E): Identify what might fail before it does.

• Deliver and defend (D): Equip for launch and plan for evolution.

The SCOPED framework doesn’t replace humans in System Design; it focuses on AI doing the grunt work and humans refining and correcting the AI’s outputs. It’s built for architects and engineers who want to move faster without cutting corners.

Let’s start with the first phase, which is to set the vision.

Step 1 — S: Set the vision#

Before you prompt anything, you need clarity. And before you design anything, you need intent.

AI can autocomplete an architecture diagram, but only you can decide what that architecture needs to serve. That’s why the first step in SCOPED is all about human leadership: defining the core product vision, the system’s boundaries, and the high-level requirements that will drive everything else.

Let’s say we’re designing a global video streaming platform. Like Netflix, it should meet the following goals:

• Deliver on-demand video to millions of users across devices and geographies.

• Provide fast, seamless streaming experiences.

• Offer personalized recommendations based on watch history and preferences.

• Handle billing, subscriptions, and access control.

The output of this phase should be a list of functional and nonfunctional requirements (and, optionally, constraints).

How to prompt AI to help with requirements#

At this stage, AI is not your strategist; it’s your assistant. Use it to help structure your thinking, not define your requirements.

Asking AI directly for a system’s requirements can lead to generic or incomplete solutions, as AI lacks the domain-specific understanding and context that human expertise provides in defining nuanced, real-world requirements.

You will then review and refine the AI output to meet your goals. The following illustration shows what a prompt-led System Design could look like in gathering requirements:

In the illustration:

• The user begins by drafting instructions and defining the system’s goals, forming the prompt together.

• This prompt is given to the AI tool, which generates clear, refined requirements for edge cases.

• The user then reviews and updates these requirements as needed.

After gathering requirements, you can leverage AI to help identify subsystems.

Step 2 — C: Chunk the system#

You wouldn’t ask an engineer to build Netflix in one go, right? So, it doesn’t make sense to ask AI to do it either. In this phase, we will take the requirements from before and break down the system into smaller subsystems that can fulfil those requirements.

Massive systems aren’t built whole. They’re decomposed into meaningful components like content delivery, user interaction, personalization, billing, etc. This is where architectural thinking shines. As a System Designer, it’s your job to identify responsibilities, define boundaries, and create independently ownable and scalable systems. While AI can assist in identifying potential boundaries or edge cases by suggesting scenarios based on its training data, it’s ultimately the System Designer’s responsibility to interpret those suggestions in the context of the specific system being built.

The output of this phase should be a list of subsystems (which can be thought of as services), their roles, and their responsibilities.

How to prompt AI to help with identifying subsystems#

You will use your previously created list of requirements and a useful prompt that may include subsystems you have already identified to get the AI to fill in the gaps.

Note: Some of the upcoming prompt examples will share the same context. To avoid repetition, I’ll use a placeholder like “[Same context as above]” instead of repeating the full context.

The subsystems you identify should map to the requirements and goals you drafted in the first step. Here’s an example of what subsystems for a Netflix-like system may look like:

Try it for yourself with the Prompt AI widget below. It is preloaded (i.e., it already has context of the requirements we generated in the last phase) for designing a Netflix-like system. To start, try using the example prompts above or ask, “What subsystems are needed for this system?”

Once you’ve identified the subsystems, AI can assist in optimizing their various components and interactions.

Step 3 — O: Optimize the subsystems#

By now, you’ve broken your system into meaningful chunks. The job is no longer about “What should I build?” It’s about “How do I make each part scalable and more resilient?”

You already have a preliminary view of the design. Now, you’re using AI to stress-test it, pressure-check your assumptions, and accelerate implementation details, not to generate them from scratch.

It's essentially about asking AI to react to your design:

• You define the interface, then prompt for overlooked edge cases.

• You sketch the API architecture, then prompt for failure scenarios or completeness.

• You decide the architecture, then prompt for risks in coupling or data flow.

After this phase, you should have everything ready to start creating the System Design. This includes all the Netflix-scale system’s subsystems, goals, and scalability requirements.

How to prompt AI to help with refinement#

Here, you will refine what you have created in the previous two phases, so we will cover various aspects of using AI.

Note: Effective AI prompting starts with context. Instead of depending solely on the model’s knowledge, infuse your prompts with your expertise to guide and elevate the outputs you get.

Let’s see an example of how AI can help refine the personalization subsystem:

Here are a few samples of improvements AI may suggest:

• “Have you considered using implicit signals like scroll depth and hover time to improve cold-start recommendations?”

• “You could split the ranking model into short-term and long-term intent predictors for better personalization.”

• “Adding real-time feedback from the search subsystem could improve freshness in trending content recommendations.”

Then, your job is to identify and implement the suggestions that align with the system’s goals.

Step 4 — P: Piece together outputs#

Now that you’ve refined your system components and scoped each service’s responsibilities, it’s time to connect the dots.

This is where isolated components evolve into a working system. The focus shifts to interactions, what flows where, who talks to whom, and how data moves across boundaries.

You’re using AI to help integrate and validate the various components (subsystems) to create a useful design.

For each subsystem, think about asking for:

• What data does it accept and send?

• How often does it communicate?

• What components must it communicate with?

How to prompt AI to help with consolidated design#

 You need to include as much context as possible to effectively prompt AI to create a high-level design and its associated details.

After refinement, you should have a practical and expandable design for your Netflix-like system. Then, you can evaluate and test the System Design against real-world concerns.

Step 5 — E: Evaluate and stress-test#

At this point, you’ve outlined the system. Now, the focus shifts from creation to chaos.

AI excels at generating plausible failure scenarios but cannot often separate realistic scenarios from hypothetical ones. That’s where your expertise comes in: craft prompts to surface potential failure modes, then apply engineering judgment to identify what truly matters.

The purpose of this phase is to figure out failure scenarios like:

• What happens if a user request is redirected to an overloaded region?

• Does the recommendation engine produce stale results?

• Content ingestion lags behind marketing timelines?

How to prompt AI to help with evaluating the design#

Start by defining the context: Which subsystem are you testing? What assumptions could fail under load or unexpected inputs?

Then, use AI to explore edge cases, propose potential failure modes, or suggest fault-injection strategies, not as a substitute for your judgment, but as a catalyst for deeper analysis.

By following these guidelines, you can test each subsystem against hypothetical but real-world scenarios and iteratively improve your design.

Once a system is fully designed and tested, the next challenge is ensuring it can perform well in real-world conditions, where resilience, adaptability, and continuous evolution are essential. Let’s now explore how you can leverage AI’s assistance during deployment.

Step 6 — D: Deliver and defend#

After deploying, your job isn’t finished.

Your system may perform well in theory, but how will it handle issues after deployment? Like a malfunctioning client app, or a sudden 10x spike from a global content release?

Every second of production yields valuable data, and AI can help you sift through the noise by helping:

• Identify underutilized subsystems: Components that might be overly resilient or too loosely coupled to be critical.

• Suggest refinements: Give feedback based on operational metrics (e.g., throughput variance, outlier detection, etc.).

• Predict areas for evolution: Can your current system handle a new streaming format? How would you upgrade it to scale in response to an evolving media landscape?

How to prompt AI to help with evolving a system#

When your system enters the defense phase, asking AI to continuously evaluate its resilience to new and evolving patterns is critical.

The prompt-driven approach extends beyond launch. With effective feedback loops and human-led decision-making, you can continuously evolve the system while focusing on long-term goals, performance, and reliability.

Let me give you a bonus tip that has helped me scale the prompt-led System Design process.

Bonus hack: Build a System Design prompt library#

As engineers, we’re used to creating reusable code. Similarly, we can create reusable prompts that evolve our System Design processes. Instead of reinventing the wheel each time you must design a new architecture or integrate a new feature, you can create a robust prompt library for your System Design needs.

This library becomes a foundational asset for you and your team, enabling faster, more reliable design iteration. You enable faster prototyping and scalable design by tweaking your prompts for different scenarios.

Remember: You’re not just using AI to generate responses, you’re guiding it to be a collaborator that supports and accelerates human decision-making.

Why build a prompt library?#

Beyond saving time, a prompt library also has the following advantages:

• Consistency in design: Having a set of proven, well-structured prompts ensures that each System Design starts from a known good place, reducing the chances of inconsistent or unoptimized results.

• Collaborative evolution: Your prompt library becomes a team asset. As your team learns from each deployment, you can refine, iterate, and expand the prompt library over time to reflect better practices and design standards.

• Customization and scalability: As your system grows, your prompts should grow with it. As new challenges arise, you may add specialized prompts for specific system components, failure recovery scenarios, or advanced scaling strategies. These prompts can be useful for future systems to catch issues before they harm the system.

So, creating a prompt library and using effective versioning strategies can supercharge your use of AI in System Design.

Designing with AI#

Prompt-Led System Design is about using well-crafted prompts to drive better design conversations, faster explorations, and richer perspectives. With the SCOPED framework, you have a structured way to collaborate with AI while keeping human expertise at the center.

We don’t need to rebuild large-scale systems like Netflix. But we can, and should, think like the engineers who did.

With AI by your side, having a solid grasp on System Design is more important than ever. You can get hands-on with designing large-scale systems from YouTube to Uber with our popular courses: