roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Answer Elasticsearch interview questions from index design to running a cluster. Covers how search works, mappings and analysis, the query DSL and relevance, aggregations, sharding, and the Elastic Stack.
204 of 204 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 204 new. 0 cut, outside your plan.
Elasticsearch comes up as a component far more often than as a subject: in a system design question about product search or a log platform, or in a deep dive on the résumé line that says you ran it. DevOps and SRE loops add the cluster itself and what it does when a node disappears.
The questions tend to start from a surprise. A term query for Quick finds nothing in a field that plainly contains the word, because the text field was lowercased by its analyzer at index time and a term query is not analyzed. A document indexed a moment ago is missing until the next refresh makes its segment searchable. A terms aggregation reports counts that are slightly off, because each shard sent back only its own top buckets.
The follow-up usually goes one level down, into Lucene: segments are never modified in place, so an update marks the old document deleted and writes a new one, and the disk comes back only when segments merge. From senior level up, the talk moves from mechanism to decisions that are hard to undo: how many primary shards a daily log index should get, why that number cannot simply be raised on a live index, and how to change a mapping behind an alias without downtime.
Elasticsearch itself does not appear until the second module. The plan opens on what any search engine does, from the inverted index to how BM25 scores a match and how evaluation shows that a ranking change helped. Vector and hybrid search sit there too, so dense retrieval arrives as one more way to rank. Lucene follows because Elasticsearch is a distributed layer over Lucene indexes: segments and merges explain refresh, and doc values explain why a field you can search is not always one you can sort.
The engine module then follows the hub's write-then-read path. Mappings and analyzers come first because they fix, at index time, what any query can later find. The query DSL and aggregations read the index back, and ranking returns a second time, now as Elasticsearch scores it, shard by shard. Sharding and replication closes the module: where a document lives and what survives a lost node make sense only once you know what the document holds.
The last two modules leave the engine for what surrounds it: the Elastic Stack and Kibana, the log pipeline and dashboards many operations teams know it from, and Elastic Cloud, which hands much of the cluster work to the vendor.
A backend engineer adding search to a product gets most from the first two modules, and relevance tuning is where a product-search design round goes once the basic query works. An SRE hired to run a logging cluster reads from the other end, the Elastic Stack, then sharding, then Lucene's merges, because shard sizing, disk watermarks and merge pressure are what on-call questions are made of. Short on time, narrow level before anything else, keeping only the steps around the title you are applying for, since the two ends ask about different halves of the plan: field types and query syntax at the bottom, shard sizing and live mapping changes at the top. Importance cut to must know trims what remains. With more time, run a single-node cluster beside the reading and break it on purpose: a mapping conflict, a replica that cannot be assigned, a score the `_explain` API has to account for. The plan ends at the cluster and the Elastic tooling around it. The service built around the index, with its API, its cache and the queue that keeps the index in step with the primary database, belongs to the [System Design roadmap](/roadmaps/system-design); when that queue is Kafka, the [Apache Kafka roadmap](/roadmaps/kafka) picks it up.
A backend engineer adding search to a product gets most from the first two modules, and relevance tuning is where a product-search design round goes once the basic query works. An SRE hired to run a logging cluster reads from the other end, the Elastic Stack, then sharding, then Lucene's merges, because shard sizing, disk watermarks and merge pressure are what on-call questions are made of.
Short on time, narrow level before anything else, keeping only the steps around the title you are applying for, since the two ends ask about different halves of the plan: field types and query syntax at the bottom, shard sizing and live mapping changes at the top. Importance cut to must know trims what remains. With more time, run a single-node cluster beside the reading and break it on purpose: a mapping conflict, a replica that cannot be assigned, a score the _explain API has to account for.
The plan ends at the cluster and the Elastic tooling around it. The service built around the index, with its API, its cache and the queue that keeps the index in step with the primary database, belongs to the System Design roadmap; when that queue is Kafka, the Apache Kafka roadmap picks it up.