Design a Feature Flag Service

Feature flag service inspired by LaunchDarkly and Unleash: flag rules live in a database, apps read them from a cache or the CDN edge, and changes are pushed out in the background with an audit trail.

Functional requirements

  • Evaluate a flag for an app instance: given the flag key and a user or context, return on or off (or a variant) from the flag's rules
  • Let an admin create or change a flag and its rules (percentage rollout, user lists, environments)
  • Push each change out to every reader within 30 seconds, through the cache and the CDN edge
  • Record every change in an audit log: who changed what, when, and the previous value
  • Let apps keep working with their last known flags when the flag service or its database is unreachable
  • Limit admin changes per minute and require a valid key for each environment

Non-functional requirements

  • Flag fetch < 50ms p99 from the edge or cache; evaluation happens in the app, so a fetch is only a rules download
  • A change reaches readers within 30 seconds (publish through a queue, then purge the cache)
  • Handle 10K flag fetches per second at peak and about 1 change per second
  • Reads stay available during a database outage: the cache and edge hold the last published rules
  • The audit log is append-only and never loses an entry (99.999% durability)
  • Scale to 1M app instances without any of them hitting the database
  • 99.99% availability for flag reads

How the design evolves

Stage 1: Read the Database on Every Check

See why querying the database for every flag check does not scale.

What was missing: A flag check should not need a database query.

Why that's risky: Flags change a few times a day but are read 10K times a second, so the database spends its capacity re-reading data that almost never changes, and a database blip breaks every app that depends on flags.

What gets added: One server that queries the database for every flag check and saves flag changes.

Trade-offs: Always fresh, but flag availability becomes database availability.

Stage 2: Flag Service and Cache

Separate reads from changes and serve reads from memory.

What was missing: Reads and changes share one path and every check hits the database.

Why that's risky: After a change the cache can serve the old rule until refreshed, and a mass expiry can stampede the database.

What gets added: A read service answers from a cache of flag rules and refills it from the database on a miss; a separate admin service writes changes.

Trade-offs: A few seconds of staleness is fine for a gradual rollout, but not for an emergency kill switch.

Stage 3: CDN at the Edge

Serve flag snapshots from the edge so a restart storm never reaches origin.

What was missing: Every instance still calls our servers, and a release that restarts thousands of instances sends them all at once.

Why that's risky: An edge copy lives until its TTL ends or it is purged, so a kill switch needs a short TTL or an explicit purge.

What gets added: A CDN serves each environment's flag snapshot from the edge so SDKs fetch it without reaching our servers.

Trade-offs: A long TTL means less origin load but a slower kill switch. Services such as LaunchDarkly keep a streaming connection open to each SDK and push changes, using the CDN only for the first download.

Stage 4: Publishing Changes, Audit and Limits

Push changes out in the background and keep an audit trail.

What was missing: Changes are not published, nothing is audited and anyone can flood the admin.

Why that's risky: Without an audit trail you cannot answer 'who turned that off?' during an incident.

What gets added: A change queue and publish workers that refresh the cache, purge the CDN snapshot, push the change to connected SDKs over a streaming connection and write an audit record; an audit database and an admin rate limiter.

Trade-offs: Publishing is asynchronous, so a flip reaches SDKs in about a second instead of inside the admin request, in exchange for never blocking the admin.

PRISM
System Design Interview
Round 1 of 4 · Architecture Design · 60:00 remaining
PRISM logo PRISM logo
Problems
AI Interview
Interview Challenges
Build & Stress Test NEW
System Architectures
Design & Fix NEW
Interactive Roadmap
Problems
Today's mission
Notifications
    Theme
    Pricing Community NEW Send feedback Report a problem NEW
    Sign in
    Theme
    Community NEW Send feedback Report a problem NEW
    All problems
    Phase
    Build & Stress Test
    Phase 01: Thinking in Systems
    Upcoming

    Components

    User
    CDN
    Load Balancer
    Server
    Cache
    Database
    Blob Storage
    Search Index
    Queue
    Worker
    Rate Limiter
    Service
    API Gateway
    Reverse Proxy
    WebSocket Server
    Third-party API

    Inspector

    Notes
    Use clear names so your design intent is easy to understand.
    Good
    Name by business meaning
    "Order API", "Restaurant Service"
    Avoid
    Generic names = zero signal
    "Server 1", "API", "Queue"
    A short description for each component makes feedback much better.
    100%
    Start by identifying:
    • Users & entry points
    • APIs & services
    • Databases & storage
    • Traffic flow & scale

    Round 1 of 4 Architecture Design

    Run a simulation to see results.

    Time Remaining
    60:00
    System Design Interview

    What are the core functional requirements?
    What are the key non-functional constraints?

    Questions

    Start Evaluation to unlock questions.

    Test yourself like it's the real thing.

    Interview prep guide
    Architecture Design
    Draw your system on the canvas. Define components, connections, and data flow.
    FR & NFR Requirements
    Answer functional and non-functional requirement questions about your design.
    MCQ Round
    Multiple choice questions testing your depth on the chosen system.
    Tradeoff Analysis
    Justify your design decisions and defend your architectural tradeoffs.
    AI interviews left 0left
    This week 0 / 0
    Used today 0 / 0

    Choose a Problem
    No problem selected
    • 30 min
    • 45 min
    • 60 min
    Round 2 of 4
    MCQ Round
    Answer multiple-choice questions based on your design.

    Exit Interview?

    You're in the middle of an interview session. Leaving now will end your current attempt.

    Your progress will be saved.

    Open a saved design

    Select a design to load into the canvas.

    My Evaluations

    Your past evaluation sessions

    Here’s a simple request flow that follows the expected layer order.

    External User
    →
    Edge CDN → API Gateway → Load Balancer
    →
    Compute App Servers / Services
    →
    DataAccess Cache
    →
    Storage Database / Search Index
    →
    Async Queue → Worker

    Tip: keep arrows moving forward through layers (Edge → Compute → Storage). Avoid sending storage back to compute.

    Evaluation Instructions

    Read the rules carefully before starting. The test auto-submits on refresh.

    Before you start

    • Build your architecture on the canvas. The timer starts when you click Start Evaluation.
    • Don't forget to answer Functional Requirement and Non Functional Requirements.
    • When satisfied with your design, click Next to lock it and view the questions.
    • Please answer final step questions to complete the evaluation.

    Dos

    • Do read each question carefully before answering.
    • Do include required components to maximize component coverage.
    • Do save a copy of your design if you want to keep it before submission.

    Don'ts

    • Don't refresh or close the tab during an active evaluation — this will auto-submit your answers.
    • Don't switch app modes or open another tab while the evaluation is running.
    • Don't attempt to edit the design after clicking Next; the workspace will be locked.

    All the best!!

    Confirm

    Input

    Notice

    Evaluation Report
    Report a problem

    Evaluation Complete

    Generating Your Report

    Hang tight — our AI is evaluating your design…

    Did you know?

    Loading…

    Share feedback

    Tell us what worked well and what we can improve.

    Let's personalize this

    Answer a couple of quick questions so we can tailor your journey and missions.

    Your welcome gift: of Full PRISM Access

    Your Pro access starts as soon as you press Start my journey.

    SYSTEM BRIEF

    System Constraints

    What the system must do — every item is a user-facing behaviour your architecture must support.

      ↑ Engineering Constraints

      These are the failure modes you must design against — latency SLAs, durability targets, traffic ceilings.

        ⇆ Architecture Constraints

        Core Concepts to Master

        Your Journey
        PHASE – –
        0 / 0 0%
        0
        Mock Interview Checklist

        Pick a topic to start

        Explore concept overviews, real-system examples, key tradeoffs, and interview talking points for each roadmap section.

        Phase Mastered

        You've conquered this phase. These are the skills you now own:

          +500 XP

          Company Interview Paths

          Progress Summary