Vibe coder or product engineer system design interview questions

As asked

Design a URL shortener that handles 10 million links, 1000 writes per second, and 50,000 reads per second. Users also need click analytics per link. Walk me through the data model, the short code generation strategy, and the read path.

Sample answer outline

The data model is a links table with columns for id, short_code, original_url, user_id, created_at, and a clicks table. Short codes can be base62 encoded random IDs or a hash of the long URL with collision detection. The read path is latency-critical so you cache the short_code to URL mapping in Redis with a high TTL, the redirect hits Redis first and falls back to Postgres. For analytics, writing a row per click at 50k req/s would saturate Postgres, so you buffer click events in Redis or a queue and flush to the analytics table in batches. A strong answer also covers custom slugs, link expiry, and the CDN as the outermost cache layer.

Expect these follow-ups

• How do you prevent the top-1000 links from becoming a hot spot in your Redis cache?
• How would you implement per-country click breakdown?

As asked

A founder asks you to 'add team invites and billing seats' using a coding agent. How do you turn that prompt into a plan the agent can execute safely?

Sample answer outline

A strong answer decomposes the request into product rules, data model changes, API contracts, UI states, and migration or billing provider concerns before asking an agent to edit code. The candidate should identify risk areas: authorisation, duplicate invites, race conditions around seat limits, webhook idempotency, and auditability. Good agent instructions include file scope, acceptance criteria, test commands, and explicit non-goals. They should iterate in small diffs and verify each step rather than requesting a sweeping feature in one prompt. Interviewers look for product judgement and engineering control, not prompt bravado.

Expect these follow-ups

• What would you ask the founder before writing code?
• Which part would you implement manually rather than delegate to an agent?
• How do you check that billing webhooks are idempotent?

As asked

Your product needs to deliver webhooks to customer endpoints when events happen. A customer's server is sometimes down. How do you design the delivery system so events are not lost, and how do you handle ordering and duplicate delivery on the consumer side?

Sample answer outline

Webhook delivery should be queued and retried with exponential backoff, storing each delivery attempt with timestamp and HTTP status so you can show customers a delivery log. Events must be persisted before the delivery attempt, not after, so a server crash does not lose events. On ordering: most webhook systems do not guarantee strict ordering because retries cause redelivery; instead each event carries a created_at timestamp and a monotonic sequence number per resource so consumers can detect and reorder. For idempotency you generate a unique event ID and customers should store processed IDs to skip duplicates. A strong answer also covers signing webhook payloads with HMAC-SHA256 so customers can verify authenticity.

Expect these follow-ups

• How do you prevent a single slow customer endpoint from blocking delivery to all other customers?

As asked

You are building a B2B SaaS where each customer is an organisation. Walk me through the three main approaches to data isolation, the tradeoffs of each, and which you would pick for a startup that expects to go from 10 to 1000 enterprise customers.

Sample answer outline

The three approaches are shared schema with a tenant_id column and RLS, separate schemas per tenant in the same database, and separate databases per tenant. Shared schema with RLS is the simplest to operate and scales well for the early stage: one schema to migrate, no connection pool explosion. The risk is a bug in RLS leaking cross-tenant data. Separate schemas give stronger isolation without multiple databases but schema migrations must run per tenant. Separate databases give the strongest isolation and enable per-customer SLAs but multiply operational overhead and connection pool pressure. For a startup going to 1000 customers, shared schema with RLS plus robust automated testing of the policies is the right call, with a migration path to per-tenant schemas for enterprise contracts requiring data residency.

Expect these follow-ups

• How do you safely run a schema migration across all 1000 tenants without downtime?

As asked

A user with 500,000 followers posts something. Every follower should receive a notification. Walk me through the fan-out architecture and why naive approaches fail at this scale.

Sample answer outline

Naive fan-out on write inserts a notification row per follower synchronously, which takes minutes for a celebrity post and blocks the post API. The fix is to push the post event to a queue, have worker processes fan out to followers asynchronously. At 500k followers you need multiple parallel workers each processing a shard of followers. For delivering push notifications you batch calls to APNs/FCM rather than one call per device. Fan-out on read is the alternative where you do not write per-follower at write time but aggregate the feed on read from a timeline, but this makes read expensive. A hybrid approach is fan-out on write for most users with fan-out on read for celebrity accounts, which is what Twitter historically used.

Expect these follow-ups

• How do you handle a follower who is offline and comes online 3 days later expecting to see their notifications?

As asked

You have a product feature backed by an LLM API that costs $0.003 per request. Some users are making thousands of requests per day, threatening your unit economics. Design a system that controls per-user AI spend without destroying the user experience.

Sample answer outline

Track per-user AI credit consumption in real time using Redis counters keyed by user ID and day, incremented by the estimated token cost of each request. Set soft limits that show a warning and hard limits that block further AI calls until the next day or until the user upgrades. On the server, before calling the LLM, check the counter and reject if the limit is exceeded. For the cost estimate, use the token count from the API response to update the counter post-call, not a pre-call estimate, since input prompt tokens vary. A strong answer also covers caching identical or semantically similar requests with a short TTL to reduce redundant LLM calls, streaming partial completions so the user sees value even if a session is long, and tiered pricing where power users pay for higher limits.

Expect these follow-ups

• How do you handle a request that starts processing but hits the limit mid-stream?

As asked

You want to track user events in your product like page views, button clicks, and feature usage, and make them queryable within 5 minutes of occurring. You have a Postgres database already. Walk me through a pragmatic architecture that does not require a full data warehouse.

Sample answer outline

The simplest approach is a single events table in Postgres with columns for event_name, user_id, properties JSONB, and created_at. Partition the table by month so old data can be archived cheaply. Batch events on the client and send them to a lightweight ingest endpoint that does a bulk insert. For the 5-minute freshness requirement, real-time inserts with a created_at index satisfy most dashboard queries. When Postgres becomes the bottleneck for analytical queries, add a read replica for analytics or use a materialized view for the most common aggregations refreshed on a schedule. A strong answer also covers client-side buffering to avoid losing events on page unload, using sendBeacon instead of fetch for page unload events, and schema-on-read via JSONB for evolving event shapes.

Expect these follow-ups

• At what point would you move events out of Postgres and into ClickHouse or BigQuery, and what triggers that decision?

As asked

Your product lets users upload profile photos and content images up to 20MB. Images must be resized to multiple dimensions, served from a CDN, and old formats converted to WebP. Walk me through the processing pipeline and serving architecture.

Sample answer outline

Upload goes directly to S3 via presigned URL. An S3 event triggers a Lambda or worker that uses Sharp to generate multiple size variants, converts to WebP with a JPEG fallback, and stores outputs to a separate serving bucket with cache-control headers set to long TTL. CloudFront or Cloudflare serves from the bucket and caches aggressively. For the serving URL you use a pattern like /images/{id}/{width}.webp so each variant has a unique cacheable URL. On-demand resizing with a Cloudflare Worker or an imgproxy instance is an alternative that avoids pre-generating every variant but trades storage cost for compute cost at serve time. A strong answer also covers progressive JPEG loading, the importance of stripping EXIF metadata for privacy, and setting alt text as a product requirement.

Expect these follow-ups

• How do you handle animated GIFs? Do you convert them to WebP or video?

As asked

Your product has a 6-step onboarding flow that users often abandon halfway through. You want users to resume exactly where they left off when they return. Walk me through the data model and state machine for this.

Sample answer outline

Store an onboarding_state row per user with a current_step enum and a completed_steps bitmask or JSON array. Each step completion writes to the database so the state is durable across sessions and devices. On the frontend, load the current step on mount and redirect there rather than always starting from step 1. The state machine transitions are server-validated: the API for step N+1 checks that step N is marked complete so users cannot skip steps by URL manipulation. A strong answer also mentions a completed_at timestamp to stop showing onboarding to users who finished, a way to replay or skip onboarding for users who know the product, and analytics events emitted at each step to track drop-off rates.

Expect these follow-ups

• How would you handle a case where you add a new mandatory step 3 after users have already completed onboarding?

As asked

Your SaaS has free, pro, and enterprise tiers with monthly and annual billing. A subscription can be active, past due, cancelled, or paused. Walk me through the state machine, the data model, and how you gate features against the current subscription state.

Sample answer outline

The subscription row stores plan, status, current_period_end, cancel_at_period_end, and a stripe_subscription_id. Status transitions are driven by Stripe webhook events: customer.subscription.updated, invoice.payment_failed, and so on. Feature gating happens via a helper that reads the user's current plan and status: past_due users retain access for a grace period before downgrading. Cancel_at_period_end means the subscription stays active until the period end and then moves to cancelled. A strong answer covers storing plan entitlements in a separate table rather than hardcoding plan names in if statements, so changing what is included in a plan does not require a code deploy, and caching the user's current plan in the session or a short-lived Redis key to avoid hitting Postgres on every request.

Expect these follow-ups

• How do you handle a user who upgrades mid-cycle and you need to prorate the charge?

As asked

You need to show other users' cursors or caret positions in real time in a collaborative product. Walk me through the architecture from cursor movement in the browser to every other user seeing it within 100ms.

Sample answer outline

The client sends cursor position updates over a WebSocket connection to a presence server. Broadcasting to all users in the same document requires the presence server to know which connections are in which document. A single server can hold all connections for a document in memory, but when you have multiple server instances you need a pub/sub layer like Redis Pub/Sub so any server can publish a cursor update and all servers subscribed to that document channel fan it out to their local connections. For the 100ms latency target you send updates at 30 to 60 fps throttled by requestAnimationFrame, use binary encoding like MessagePack instead of JSON for payload size, and ensure the WebSocket server is geographically close to users. A strong answer also covers conflict-free representation of cursor position using logical positions rather than pixel offsets.

Expect these follow-ups

• How do you handle the case where a user's connection drops and their cursor should disappear from all other screens?