← Back to Directory

Perplexity

Small

Screna has 17 Perplexity interview write-ups. The most reported round is the technical phone screen (13).

17 interview notes · updated Jun 2026

Perplexity·Software Engineer·Technical Phone Screen

Jun 2026
Coding round at Perplexity for a Software Engineer role. The question was a classic in-memory file system implementation and I nearly got through it, but a bug at the end killed my chances. Rejection came the next day. The interviewer was pretty much a wall the whole time.
  • Implement an in-memory file system that supports creating directories and files, reading and writing file contents, and listing or searching within the file system.

“Got pretty far with it.”

View Post

Perplexity·Software Engineer·Technical Phone Screen

Jun 2026
Perplexity coding screen, one problem the whole session. You're given a tokenizer class and have to estimate token counts without actually tokenizing the full input, staying under a byte budget. Interesting constraint-based problem, felt more like a systems/estimation puzzle than a typical leetcode grind.
  • Implement an `estimate_token_count(text, sample_size, rng)` method on a `ByteTokenizer` class that approximates the full token count without tokenizing the entire input. You can call `self.tokenize` freely, but the total bytes passed across all calls must stay within `sample_size`. Return the exact count if `sample_size >= len(text)`.

“The edge case at the top saved me, checking if sample_size covers the whole input and just returning exact.”

View Post

Perplexity·Software Engineer·Technical Phone Screen

Jun 2026
Perplexity SWE interview, second part of what seemed like a multi-stage coding round. The problem escalated into task dependency graph territory and I ran out of time on the last test case.
  • Design a task scheduling system that supports dependency relationships between tasks, where a task can be BLOCKED, READY, SUCCEEDED, or FAILED. Implement the cascade logic so that state transitions propagate correctly through the dependency graph.

“My first mistake was only tracking which tasks a given task depends on, not which tasks depend on it.”

View Post

Perplexity·Software Engineer·Onsite - System Design / Architecture

May 2026
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.
  • 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.
  • How would you design the data model to handle recurring tasks and their relationship to projects?
  • What does the API surface look like for task creation when the input is a natural-language string versus structured fields?
  • How do you think about prompt design, latency, and cost when integrating an LLM into a high-frequency user interaction like task creation?
  • How would you handle syncing task state across multiple devices, especially when the user makes changes offline?

“This question is basically five questions duct-taped together.”

View Post

Perplexity·Software Engineer·Technical Phone Screen

May 2026
Coding round at Perplexity for a software engineer role. The problem was a multi-part Python implementation using some provided class scaffolding, and part one was pretty straightforward CRUD stuff. Pacing was the real challenge.
  • Implement a ToDo list in Python using three provided classes (TaskStatus as an enum, Task, and ToDoList), completing all four parts of the problem with their respective test cases.

“Part one was basic create, read, update, delete operations.”

View Post

Perplexity·Software Engineer·Technical Phone Screen

May 2026
Perplexity SWE interview that had me extending an in-memory task management system with dependency tracking and a cascade-failure mechanism. Solid systems problem, more nuanced than it first looks once you start thinking about large graphs.
  • You have an in-memory Todo List system that supports basic CRUD on tasks. Extend it to track parent/child dependencies between tasks, then implement a cascade-failure function: when a task fails, all tasks that transitively depend on it must also be marked failed. How do you approach this, and what do you do about performance on large dependency graphs?

“The CRUD part was fine, I sketched that out quickly.”

View Post

Perplexity·Software Engineer·Technical Phone Screen

May 2026
Interviewed for a software engineering role at Perplexity and got a system design question that was more nuanced than I expected. The core idea sounds simple but the edge cases pile up fast.
  • Design a key-value store where every set, get, and delete operation is associated with a timestamp. A get at time t should return the most recent value from any set or delete with timestamp <= t, where delete acts as a tombstone.

“I started with the obvious thing, a sorted list per key where each entry stores the timestamp, the operation type, and the value.”

View Post

Perplexity·Software Engineer·Technical Phone Screen

May 2026
Coding round at Perplexity for a software engineer role. The problem involved deduplicating sources and then reordering them by their appearance in paragraphs. Finished the code but tripped on edge cases, so probably a rejection.
  • Given a list of sources and a set of paragraphs, first deduplicate the sources, then reorder them according to the sequence in which they appear across the paragraphs.

“Got the main logic working but edge cases killed me.”

View Post

Perplexity·Software Engineer·Take-home Assignment

Apr 2026
Perplexity take-home where you get handed a tokenizer codebase and have to actually read it before doing anything else. The first task is just writing a description of how the algorithm works, which sounds easy until you realize your assumptions about tokenization are probably wrong.
  • Study the provided tokenization implementation and write a precise natural-language description of how the algorithm works, detailed enough for another engineer to reimplement it from scratch.

“This tripped me up more than I expected.”

View Post

Perplexity·Software Engineer·Online Assessment (OA)

Apr 2026
Perplexity gave me a timed coding assessment centered on optimizing a tokenizer implementation in Python. The core task was making a slow reference method fast enough to process ~500KB of text against a 10k+ token alphabet in under 10 seconds total. Interesting problem, though the pressure of matching exact reference behavior while also hitting performance targets made it stressful.
  • You're given a reference tokenization algorithm in a slow method. Reimplement it in a faster method that produces byte-for-byte identical output, processing ~500KB of text against 10,000+ tokens in under 10 seconds total.

“The tricky part isn't just making it fast, it's that you can't deviate from the reference behavior at all even if you think the reference is doing something dumb.”

View Post