← Nooks Interview Insights

Nooks·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
May 2026

Summary

System design round at Nooks for a software engineer role, basically one big question about designing Twitter from scratch. Covered a lot of ground in not that much time, felt like I was constantly making trade-off calls without enough space to fully justify each one.

Questions Asked (5)

Q1

Design a system like Twitter, covering core features like posting tweets, following users, viewing a personalized home timeline, search, and notifications.

System DesignTechnical Trade-offs
Author's notes

I started with requirements scoping which felt okay, read-heavy workload, eventual consistency is fine, low-latency reads matter most.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then design the core data model and APIs for tweeting and following. Focus on the home timeline generation strategy (fan-out on write vs. read) and discuss trade-offs for search and notifications. Wrap up with scalability, reliability, and monitoring considerations.

Pro tip: Explicitly compare fan-out on write vs. fan-out on read for timeline generation, and propose a hybrid approach for celebrities—this shows you understand real-world trade-offs at scale.

1. Clarify Requirements and Scale

Ask about expected user count, daily active users, tweet volume, read/write ratio, and latency requirements. Define core features and prioritize them.

2. High-Level Architecture and Data Model

Sketch the main components: clients, API gateway, services (tweet, user, timeline, search, notification), and storage (SQL/NoSQL, cache, search index). Define key entities and relationships.

3. Deep Dive into Timeline Generation

Explain fan-out on write (push) vs. fan-out on read (pull) for home timelines. Discuss trade-offs and propose a hybrid approach for high-follower accounts.

4. Design Search and Notifications

Outline how to index tweets for search (e.g., inverted index, Elasticsearch) and how to deliver notifications (push, pull, or hybrid) with prioritization and batching.

5. Address Scalability, Reliability, and Trade-offs

Discuss partitioning, replication, caching, rate limiting, and monitoring. Summarize key trade-offs and how you would evolve the design.

Key Points to Mention

  • Fan-out on write vs. fan-out on read for timeline generation, with hybrid approach for celebrities
  • Data storage choices: SQL for user graph, NoSQL for tweets, cache for timelines, search index for search
  • Caching strategies: Redis for timeline cache, CDN for media, and cache invalidation
  • Sharding and replication for scalability and fault tolerance
  • Notification delivery: push vs. pull, batching, and prioritization
  • Trade-offs: consistency vs. availability, latency vs. cost, and complexity vs. maintainability

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q2

Walk through the trade-offs between pushing tweet fan-out to followers' feeds on write versus pulling and merging tweets on read, and when you'd use a hybrid approach.

System DesignTechnical Trade-offsData Modeling
Author's notes

This is where I spent most of my time and it went reasonably well.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by defining the core problem: fan-out on write (push) vs. fan-out on read (pull) for delivering tweets to followers' feeds. Compare them across dimensions like latency, scalability, storage, and consistency, then explain when a hybrid approach (e.g., push for active users, pull for celebrities) makes sense.

Pro tip: Mention that the choice depends on read/write ratios and user behavior patterns—most systems use a hybrid because pure push or pull doesn't scale for all scenarios. Also, highlight the importance of caching and precomputation in reducing latency.

1. Define the approaches

Clearly explain fan-out on write (push) and fan-out on read (pull), including how each handles tweet delivery to followers' feeds.

2. Compare trade-offs

Discuss trade-offs in terms of latency, scalability, storage cost, consistency, and complexity for each approach.

3. Identify scenarios

Describe scenarios where each approach excels, such as push for users with few followers and pull for celebrities with millions of followers.

4. Introduce hybrid approach

Explain how a hybrid approach combines push and pull, e.g., pushing to active users' feeds and pulling for inactive or celebrity accounts.

5. Conclude with recommendations

Summarize when to use each approach and justify the hybrid as a scalable, balanced solution for large-scale social feeds.

Key Points to Mention

  • Latency: Push provides low read latency but high write latency; pull provides low write latency but high read latency.
  • Scalability: Push can cause write amplification for celebrities; pull can cause read amplification for active users.
  • Storage: Push requires storing tweets in each follower's feed (denormalization); pull stores tweets once and merges on read.
  • Consistency: Push may lead to stale feeds if not updated; pull always reflects latest tweets but may be slower.
  • Hybrid approach: Use push for normal users and pull for celebrities, or push to active users and pull for inactive ones.
  • Caching and precomputation: Use caches to mitigate pull latency and precompute feeds for active users to reduce write load.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q3

What data stores would you use for this system and why? Consider the timeline storage, caching layer, and any relational needs.

System DesignData Modeling
Author's notes

Talked through sharded SQL for user/follow graph data, Cassandra for the timeline inboxes since it handles wide rows and high write throughput well, and Redis for caching hot timelines.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the system's requirements—read/write patterns, scale, consistency needs, and query types—then map each requirement to a suitable data store. For timeline storage, consider a time-series database or a wide-column store; for caching, use Redis or Memcached; for relational needs, use PostgreSQL or MySQL. Justify each choice by tying it back to the specific access patterns and trade-offs.

Pro tip: Don't just list technologies; explain the trade-offs and why alternatives were rejected. Also, mention how you'd handle data consistency and failure scenarios across stores, as this shows production maturity.

1. Clarify requirements

Ask about data volume, read/write ratio, latency requirements, consistency needs, and query patterns (e.g., range queries on time, aggregations). This ensures your choices are grounded in actual needs.

2. Design timeline storage

Choose a store optimized for time-ordered data, such as a time-series database (e.g., InfluxDB, TimescaleDB) or a wide-column store (e.g., Cassandra) if write-heavy. Explain how it handles high write throughput and efficient time-range queries.

3. Design caching layer

Select an in-memory cache like Redis or Memcached to reduce latency and database load. Discuss cache invalidation strategies (e.g., TTL, write-through) and what data to cache (e.g., hot timelines, user sessions).

4. Address relational needs

Use a relational database (e.g., PostgreSQL) for transactional data, user profiles, and relationships. Mention when to use it versus NoSQL, and how to scale (e.g., read replicas, sharding).

5. Summarize and justify

Recap your choices, highlighting how each store fits the requirements and the trade-offs made. Mention operational considerations like monitoring, backups, and cost.

Key Points to Mention

  • Time-series databases (e.g., InfluxDB, TimescaleDB) for efficient time-range queries and high write throughput.
  • Wide-column stores (e.g., Cassandra) for scalability and write-heavy workloads, with tunable consistency.
  • In-memory caching (e.g., Redis) for low-latency reads, with eviction policies and persistence options.
  • Relational databases (e.g., PostgreSQL) for ACID transactions, complex joins, and strong consistency.
  • Data modeling considerations: denormalization for read performance, partitioning by time, and indexing strategies.
  • Trade-offs: consistency vs. availability, latency vs. durability, and cost vs. performance.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q4

How would you handle media storage and delivery for tweets with images or video?

System DesignAPI & Integrations
Author's notes

Pretty quick answer: object store for raw media, CDN in front for delivery.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements such as scale, media types, and latency expectations. Then propose a high-level architecture that separates upload, storage, processing, and delivery, using CDNs and object storage. Finally, dive into key components like transcoding, caching, and security, discussing trade-offs.

Pro tip: Emphasize the importance of asynchronous processing and CDN caching to handle viral tweets and ensure low latency globally. Mention cost optimization by using tiered storage and lifecycle policies.

1. Clarify Requirements

Ask about expected scale (e.g., daily uploads, peak traffic), media types (images, videos), and latency/availability requirements. This shows you understand the problem before designing.

2. High-Level Architecture

Outline the main components: client uploads to an API gateway, which stores media in object storage (e.g., S3) and metadata in a database. Use a message queue for asynchronous processing.

3. Media Processing Pipeline

Describe how media is processed: images resized/optimized, videos transcoded into multiple formats/resolutions. Use serverless functions or worker services triggered by queue events.

4. Delivery and Caching

Explain how media is delivered via CDN with edge caching. Use signed URLs for secure access and set appropriate cache headers. Discuss cache invalidation strategies.

5. Scalability and Reliability

Address scaling: use auto-scaling groups for workers, multi-region storage, and CDN failover. Discuss monitoring, retries, and dead-letter queues for failed processing.

Key Points to Mention

  • Object storage (e.g., S3) for durability and scalability
  • CDN for low-latency global delivery and offloading origin
  • Asynchronous processing with message queues (e.g., SQS, Kafka) for transcoding and resizing
  • Media transcoding (e.g., HLS, DASH) and adaptive bitrate streaming for videos
  • Security: signed URLs, access controls, and encryption at rest/in transit
  • Cost optimization: lifecycle policies, tiered storage, and compression

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q5

How would you approach search across tweets at scale?

System DesignTechnical Trade-offs
Author's notes

Said Elasticsearch and explained the indexing pipeline: write to primary store, async index into ES, accept slight staleness.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements such as scale, latency, and query types, then propose a distributed search architecture using an inverted index. Discuss trade-offs between indexing strategies, sharding, and real-time vs batch processing, and explain how you would ensure scalability and fault tolerance.

Pro tip: Emphasize the importance of measuring and optimizing for the tail latency (p99) rather than just average, as it directly impacts user experience at scale. Also, mention the need for a hybrid approach that balances precomputation and on-the-fly processing for fresh tweets.

1. Clarify Requirements

Ask about expected scale (tweets per second, total volume), query types (keyword, hashtag, user, boolean), latency requirements, and consistency needs. This ensures the design meets actual needs.

2. High-Level Architecture

Outline a distributed search system with components: ingestion pipeline, indexing service, query service, and storage. Use an inverted index for efficient text search.

3. Indexing Strategy

Discuss how to build and maintain the inverted index: batch vs real-time indexing, sharding by document or term, and handling updates/deletes. Consider using a system like Apache Lucene or Elasticsearch.

4. Query Processing and Scaling

Explain how queries are routed to relevant shards, merged, and ranked. Discuss caching, replication for read scalability, and load balancing.

5. Trade-offs and Optimizations

Analyze trade-offs: consistency vs availability, latency vs freshness, cost vs performance. Mention optimizations like tiered storage, compression, and early termination.

Key Points to Mention

  • Inverted index and its variants (e.g., distributed, compressed)
  • Sharding strategies (by document, by term, or hybrid) and their impact on query performance
  • Real-time indexing vs batch processing for fresh content
  • Replication and fault tolerance for high availability
  • Caching strategies (query cache, result cache) to reduce latency
  • Ranking and relevance (e.g., TF-IDF, BM25, or machine learning models)

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.