Question library
Search documents and methods, or filter questions. Preparation targets and page filters apply to questions. The address bar keeps your view for sharing.
What do these filters mean?
- Capability
- The one thing a question is mainly meant to examine. Each question has exactly one.
- Topic
- The knowledge or method a question touches, such as databases or growth experiments. It does not decide which capability is examined.
- Role
- Choose a software engineering specialization. Product, operations, and design are expansion capabilities for engineers.
- Responsibility scope
- How wide the responsibility reaches. A wider scope does not mean better performance.
- Career track
- Individual contributor, team manager, or senior manager. Management is not everyone’s next step.
- Use case
- Browse the same question library by external interviews, campus hiring, interviewer design, internal promotion, or reflection.
- Question format
- How evidence is gathered: explanation, coding, case, behavioral, and so on.
Documents and methods
Questions
1334 questions
- An AI assistant can create tickets, issue refunds, or change accounts on a user's behalf. A refund request times out, and the system cannot tell whether it completed; retrying may issue a second refund. How would you check the outcome, control retries, and ensure actions stay within the user's authorization?
- Two reviewers often disagree about the same set of AI outputs. How would you tell whether the issue is annotator disagreement, an unclear evaluation standard, or model instability?
- You built a customer-support Q&A prototype. How would you design an evaluation set to decide whether it may only assist retrieval, or can reply to customers directly?
- What does an algorithm model and the features it depends on truly cost? How do you count training, inference, feature computation and storage, labeling, and maintenance, and how do you judge whether a feature is worth keeping?
- A document assistant can submit most cases automatically, but mistakes have very different consequences. Human review has reduced errors, but the queue keeps growing. How would you decide which cases to automate or review, and keep the queue within the team’s capacity?
- A generative feature produces good answers, but peak latency and per-request cost exceed the product budget. How would you determine whether the cause is the model, context, retrieval, or call chain?
- After a foundation-model change, the average score improves, but outcomes worsen for a few important customers. How would you decide whether to ship, stage, or roll back?
- Your company wants an internal knowledge assistant, and document permissions change as people move around. How would you make it answer with evidence while keeping it from exposing what a user should not see?
- A resume line saying "used AI to improve engineering efficiency" carries little information. How would you rewrite it into an experience others can probe and verify?
- User satisfaction with a knowledge assistant has fallen, but offline retrieval metrics are unchanged. Which parts of the system would you investigate?
- You ask an AI to review a configuration or generate a piece of code. How do you decide whether it can go live?
- Enterprise knowledge documents may change, be withdrawn, or become restricted, yet users still receive answers citing old content. How would you propagate changes from source documents through chunks, indexes, caches, and existing citations, and prove that an update or deletion took effect?
- Production answers contain incorrect citations or degrade in quality, but prompts and retrieval context may include sensitive data and cannot be logged by default. What telemetry would help distinguish retrieval, model, and tool failures while controlling data exposure?
- A new model raises overall accuracy from 91% to 94%, but errors remain concentrated in cases that affect customer rights. The team wants to ship based on the aggregate score. How would you decide?
- A RAG assistant cites an internal document, but its owner has updated the process and the new version is not indexed yet. How would you define freshness goals, propagation, and answer behavior during the gap?
- A multi-step agent reads project permissions at startup. Before step three, the user is removed from the project, but the task still holds a tool token. How would you design authorization checks and cancellation semantics?
- A user updates account settings and refreshes immediately, but a read replica returns the old value. Reading from the primary adds load, while waiting for replication may time out. How would you design the experience?
- How do you usually handle null values, empty strings, out-of-range access, and invalid input when writing code? Tell me about a time a missing up-front check caused a problem in testing or production, and what habit changed as a result.
- A sign-up form ends up in inconsistent states because of duplicate submissions and weak-network retries. How would you map its states and transitions, and decide which logic to extract into its own unit?
- Implement a small cache that evicts the least recently used entry when full. What time cost does each operation need, and which tests do you write first?
- A user backgrounds the app while editing, and the operating system may kill its process. On return, which state should be restored and which should be reloaded, and how would you avoid losing a draft or overwriting newer data?
- You need a structure that supports fast insert, fast lookup, and ordered iteration. How would you choose among candidates, and what would you give up?
- When writing code and reviewing it, what checks have become habit for avoiding performance problems such as querying a database inside a loop or holding large objects too long? How do you know they actually work?
- Implement a retry wrapper that retries by error type, supports a maximum attempt count, backoff, and cancellation, and does not overwhelm the dependency. Define the interface before coding, then explain how to make clocks, waits, and tests deterministic.
- A very large CSV must be validated without loading the whole file into memory. On malformed rows, the tool should report line numbers and continue checking. How would you design the parser interface?
- After multiple macro and code-generation expansions, compiler errors point only to generated files, leaving users unable to find the original code. How would you design diagnostics?
- Incremental compilation is fast, but changes to a shared header sometimes fail to rebuild all dependent targets. How would you find the dependency-tracking gap?
- A compiler upgrade changes struct layout or calling conventions, but some plugins are still built against the old ABI. How would you manage compatibility and migration?
- A cache can make reads faster and can also show users stale content. How do you decide whether a piece of data suits caching, and how do you notice when it goes wrong?
- Two jobs run fine alone but occasionally hang when run together. What conditions must hold for a deadlock, and how would you confirm that is the cause?
- After a page sits idle, the first request is much slower than later ones. What network-level causes could explain it, and how would you tell them apart?
- A query filters on an indexed column and is still slow. Explain how an index lookup works and what can keep it from helping.
- A long-running process keeps using more memory, while object counts in heap snapshots fluctuate. How would you use evidence to distinguish a true leak, intentional cache retention, fragmentation, or growth in native memory?
- Your service handles requests with threads and a colleague proposes processes instead. What would you compare, and when would you push back?
- The first screen of an image-heavy page opens slowly. How would you work backwards from the symptom to the cause, and what would each improvement cost?
- What happens between writing a line of code and the CPU running it? Pick a language you know and walk through the main stages.
- When two transactions modify the same data at once, what anomalies can occur? What does each isolation level prevent, and what does it cost?
- A new field must be backfilled across hundreds of millions of rows. The first run increases lock waits and replication lag. How would you decide whether to pause, batch, throttle, or use an online migration?
- A new index speeds up queries, but write latency and storage growth worsen noticeably. How would you decide whether to keep it?
- After reads move to replicas, users sometimes cannot see a change immediately after a successful write. How would you define and handle stale reads?
- Your endpoint works in local tests, but during integration a frontend colleague insists it errors or returns nothing. What means do you use to locate the problem, and how do you produce evidence the other person will accept?
- After cache expiry, many requests hit the origin at once, and recovery causes a second traffic spike. How would you diagnose and suppress a cache stampede and warm-up storm?
- In production the same order is occasionally submitted twice, and you cannot reproduce it locally. How would you narrow it down, and would you stop the bleeding first or add observability first?
- An API has been slow since yesterday, and there is no release on record. Given logs, monitoring, and database slow-query records, in what order would you investigate?
- After splitting a large frontend bundle into several smaller ones, the first screen got slower. What causes would you suspect, and how would you verify them?
- A cache key is invalidated and logs show a database reread, yet some users still see old data. Switching to the primary helps but does not eliminate it. How would you investigate caches, replicas, and clients?
- Producer logs show an event published and the broker acknowledged it. The consumer has no visible error, but the business object did not change. How would you distinguish acknowledgment semantics, dead letters, filters, deserialization, and duplicate handling?
- A request calls four downstream services, each using a full two-second timeout. End-to-end tail latency is high, and clients continue work after the response is no longer useful. How would you propagate deadlines and budgets?
- Overall capacity is sufficient after sharding, but a few tenants still overload hot keys. How would you reassess the partition strategy?
- On-call engineers receive many alerts each day, yet user complaints and service objective violations still go unnoticed. How would you redesign alerting?
No question matches every filter.
·Your current collection 0 / 200
Only question IDs and their order are saved on this browser. Up to 200 questions; no answers, scores, or completion tracking.