← Perplexity Interview Insights

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

SeniorPrefer not to say
May 2026Remote

Summary

Perplexity system design round, one big open-ended question about building an AI-augmented to-do list app. Way more surface area than I expected and I definitely ran out of time before getting to everything.

Questions Asked (5)

Q1

Design an AI-powered to-do list app that supports natural-language task input, smart task decomposition, prioritization, and reminders. Walk through the data model, API design, LLM integration strategy, device sync, and offline support.

System DesignTechnical Trade-offsData Modeling
Author's notes

This question is basically five questions duct-taped together.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then propose a high-level architecture that separates the client (offline-first with local DB) from the backend (API, LLM orchestration, sync service). Walk through each component—data model, API, LLM integration, sync, and offline—highlighting trade-offs and how they support the core features.

Pro tip: Emphasize idempotency and conflict resolution in sync, and design LLM interactions to be asynchronous with fallbacks to rule-based parsing to handle latency and failures gracefully.

1. Clarify Requirements and Scale

Ask about expected user base, task volume, latency requirements, and offline usage patterns to scope the design appropriately.

2. Design Data Model and API

Define entities like User, Task, Subtask, Reminder, and Tag, and design RESTful or GraphQL APIs for CRUD operations, natural language input, and sync.

3. Plan LLM Integration

Outline how to use LLMs for parsing natural language, decomposing tasks, and prioritization, including prompt design, caching, and fallback strategies.

4. Address Sync and Offline Support

Describe a sync protocol with conflict resolution (e.g., last-write-wins or CRDTs), local storage on devices, and queueing of offline actions.

5. Discuss Trade-offs and Scalability

Highlight trade-offs in consistency vs. availability, LLM cost vs. accuracy, and propose scaling strategies for backend services.

Key Points to Mention

  • Use of a local-first architecture with SQLite or Realm on devices and a sync engine that handles conflicts via versioning or CRDTs.
  • API design with endpoints for natural language input (e.g., POST /tasks/parse) that returns structured tasks, and batch sync endpoints.
  • LLM integration with prompt engineering for task decomposition and prioritization, plus caching and rate limiting to manage cost and latency.
  • Offline support through local action queues and background sync when connectivity is restored, ensuring idempotent operations.
  • Data model considerations: tasks with hierarchical subtasks, reminders with time zones, and tags for categorization.
  • Scalability: using message queues for async LLM processing, sharding by user ID, and CDN for static assets.

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

Q2

How would you design the data model to handle recurring tasks and their relationship to projects?

Data ModelingSystem Design
Author's notes

Went with a separate recurrence rule table linked to tasks, something like a cron-style spec plus a next-fire timestamp.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements: what defines a recurring task, how recurrences are generated, and how tasks relate to projects. Then propose a normalized schema with separate entities for projects, tasks, and recurrence rules, and discuss how to handle exceptions and querying.

Pro tip: Mention that recurrence rules should be stored using a standard like RRULE (iCalendar) to avoid reinventing the wheel, and that you'd materialize occurrences lazily or via a scheduler to balance query performance and storage.

1. Clarify Requirements

Ask about the nature of recurring tasks: are they simple (daily/weekly) or complex (e.g., 'third Tuesday of every month')? How are exceptions handled? What queries are needed?

2. Identify Core Entities

Define the main entities: Project, Task (or TaskTemplate), and RecurrenceRule. Consider whether a recurring task is a template that generates instances or a single entity with occurrences.

3. Design Schema

Propose tables: projects (id, name, ...), tasks (id, project_id, title, due_date, recurrence_id, ...), and recurrence_rules (id, rrule, start_date, end_date, ...). For exceptions, add a table like task_exceptions (task_id, original_date, new_date, status).

4. Handle Occurrence Generation

Discuss strategies: generate all occurrences upfront (simple but storage-heavy), generate on-the-fly when queried (flexible but complex), or use a hybrid with a scheduler that materializes upcoming occurrences.

5. Address Querying and Performance

Explain how to efficiently query tasks for a project within a date range, considering indexes on project_id and due_date, and how to handle recurrence expansion in queries.

Key Points to Mention

  • Use of RRULE (iCalendar standard) for recurrence patterns
  • Separation of recurrence rule from task instances to avoid duplication
  • Handling exceptions (e.g., skipped or rescheduled occurrences) with a dedicated table
  • Trade-offs between materializing occurrences vs. generating dynamically
  • Indexing strategies for efficient date-range queries
  • Consideration of time zones and daylight saving time for recurring tasks

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

Q3

What does the API surface look like for task creation when the input is a natural-language string versus structured fields?

API & IntegrationsTechnical Trade-offs
Author's notes

I suggested a single endpoint that accepts raw text and returns a parsed task object, with the LLM call happening server-side before persistence.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying that the API surface should be consistent in its core operations but may differ in input handling. Describe a unified endpoint that accepts either a natural-language string or structured fields, with the server normalizing both into a common internal representation. Highlight trade-offs in validation, error handling, and extensibility.

Pro tip: Emphasize that natural-language input should be treated as a convenience layer that ultimately maps to the same structured schema, ensuring a single source of truth and avoiding divergent code paths. This shows you prioritize maintainability and clear separation of concerns.

1. Define the core task model

Describe the canonical structured representation of a task (e.g., title, due date, priority, assignee) that both input methods must resolve to.

2. Design the API endpoint

Propose a single endpoint (e.g., POST /tasks) that accepts a request body with either a 'text' field or a 'structured' object, using content negotiation or a discriminator field.

3. Handle natural-language parsing

Explain how the server uses an NLP parser to extract structured fields from the text, with fallbacks and confidence scores for ambiguous cases.

4. Address validation and errors

Discuss how validation differs: structured input can be validated against a schema, while natural-language input may require partial validation and user confirmation for uncertain fields.

5. Consider extensibility and versioning

Mention how to evolve the API without breaking clients, such as adding new structured fields or improving the NLP model, and how to version the parsing behavior.

Key Points to Mention

  • Unified endpoint with polymorphic input (text vs. structured)
  • Normalization to a common internal task schema
  • NLP parsing with confidence scores and fallback to structured fields
  • Validation strategies: strict for structured, lenient with confirmation for natural language
  • Error handling: clear messages for missing or ambiguous fields
  • Extensibility: versioning the parser and schema evolution

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

Q4

How do you think about prompt design, latency, and cost when integrating an LLM into a high-frequency user interaction like task creation?

Technical Trade-offsProduct Strategy
Author's notes

Probably the part I was most prepared for.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by acknowledging the tension between latency, cost, and quality in high-frequency interactions, then propose a tiered approach that optimizes each dimension based on user context and task complexity. Emphasize iterative testing and monitoring to balance trade-offs dynamically.

Pro tip: Frame latency as a product feature—users perceive speed as intelligence—and show how you'd instrument prompt performance to make data-driven decisions rather than relying on intuition.

1. Define the interaction constraints

Clarify the expected frequency, acceptable latency (e.g., <500ms for task creation), and cost per interaction budget. This sets the optimization target.

2. Design prompts for efficiency

Use concise, structured prompts with clear instructions and few-shot examples to minimize token usage and reduce latency. Consider prompt caching for repeated patterns.

3. Implement tiered model routing

Route simple, high-frequency requests to smaller, faster models (e.g., 7B) and complex ones to larger models. Use fallbacks and caching to handle spikes.

4. Measure and iterate

Instrument latency, cost, and quality metrics (e.g., user edit rate) to identify bottlenecks. A/B test prompt variations and model choices to optimize trade-offs.

5. Optimize for perceived performance

Use streaming responses, optimistic UI updates, and pre-fetching to make interactions feel instant even if backend latency is higher.

Key Points to Mention

  • Token efficiency: shorter prompts reduce cost and latency, but may sacrifice quality; find the sweet spot.
  • Model selection: smaller models for simple tasks, larger for complex; consider fine-tuning for domain-specific tasks.
  • Caching: cache frequent prompts/responses to avoid redundant LLM calls.
  • Streaming: stream tokens to improve perceived latency for longer responses.
  • Monitoring: track latency, cost, and quality metrics (e.g., user satisfaction, edit rate) to guide optimization.
  • Fallback strategies: graceful degradation if LLM is slow or unavailable (e.g., rule-based fallback).

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

Q5

How would you handle syncing task state across multiple devices, especially when the user makes changes offline?

System DesignTechnical Trade-offs
Author's notes

Rushed through this at the end.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements: what types of tasks, expected offline duration, and consistency needs. Then propose a client-server sync architecture with local persistence, conflict resolution, and a sync protocol. Walk through the offline scenario step-by-step, highlighting trade-offs and how you'd handle conflicts.

Pro tip: Emphasize that you'd design for eventual consistency and use a conflict-free replicated data type (CRDT) or operational transformation (OT) for automatic merging, but also mention the importance of a fallback manual resolution for complex conflicts. This shows you understand both the technical and user experience aspects.

1. Clarify Requirements

Ask about the nature of tasks (e.g., text notes, structured data), expected offline duration, number of devices, and consistency requirements (strong vs eventual).

2. Design Local Storage & Sync Protocol

Propose a local database (e.g., SQLite, IndexedDB) to store tasks and a sync protocol (e.g., WebSocket, HTTP long-polling) with a server that maintains the authoritative state.

3. Handle Offline Changes

Describe how changes are queued locally when offline, with timestamps or version vectors, and synced when connectivity returns.

4. Conflict Resolution Strategy

Explain how conflicts are detected (e.g., version vectors) and resolved (e.g., last-write-wins, CRDTs, OT, or manual user resolution).

5. Discuss Trade-offs & Edge Cases

Compare approaches (e.g., CRDTs vs OT vs server reconciliation), discuss scalability, latency, and user experience implications.

Key Points to Mention

  • Eventual consistency and the CAP theorem trade-offs
  • Conflict-free replicated data types (CRDTs) or operational transformation (OT)
  • Version vectors or logical clocks for causality tracking
  • Local-first architecture with background sync
  • User experience for conflict resolution (e.g., merge UI)
  • Security and authentication for sync (e.g., end-to-end encryption)

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