50+ Advanced ELK Stack Interview Questions (2027)
52 advanced ELK Stack interview questions on node roles, shard sizing, logsdb, TSDS, ILM tiers, CCR/CCS, security and design scenarios.
Advanced ELK Stack interviews test whether you can design an Elastic cluster, not just run one. Expect questions on node roles and cluster formation, shard and tier layout, data stream types such as logsdb and TSDS, mappings at scale, ingest pipeline design, security between clusters, snapshots, cross-cluster replication and search, and performance tuning, followed by open design scenarios.
This page is the architect-level member of our ELK interview series. If you need the core definitions first, start with the main 80+ ELK Stack interview guide. For hands-on commands, see the fresher questions; for streaming and latency topics, the real-time ELK questions; and for day-to-day operations, the ELK engineer questions for experienced candidates. The questions below avoid repeating those pages and go one level deeper into design trade-offs. Logging also sits inside a wider observability picture, covered in our observability tools guide.
Key takeaways
- Interviewers at this level want reasons: why a node role, why a shard count, why a tier, and what each choice costs.
- Know the newer storage options: logsdb index mode (GA in Elastic Stack 9.0 and applied to new
logs-*-*data streams), time series data streams for metrics, and the data stream failure store (GA in 9.1). - Shard guidance from Elastic: aim for 10 GB to 50 GB per shard and under 200 million documents.
- Searchable snapshots power the cold and frozen tiers and need an Enterprise license.
- Cross-cluster replication is active-passive and pull-based; cross-cluster search reads remote data without copying it.
- Design answers should start with requirements (volume, retention, query patterns, recovery targets) before naming any setting.
How this guide is organised
| Section | Questions | Who it suits |
|---|---|---|
| Foundations for architect rounds | 1 to 10 | Engineers moving from operations into design work |
| Intermediate design (2 to 5 years) | 11 to 26 | Engineers who already run a production cluster |
| Senior and architect | 27 to 42 | Leads, platform owners, solution architects |
| Design scenarios | 43 to 52 | Whiteboard and system design rounds |
Foundations for architect rounds
1. How does an Elasticsearch cluster form, and which settings control it?
Nodes find each other through discovery.seed_hosts, which lists addresses of master-eligible nodes. On the very first start of a brand new cluster, cluster.initial_master_nodes names the master-eligible nodes that vote in the first election. After the cluster has formed once, remove that setting; leaving it in place risks a node bootstrapping a second, separate cluster if it restarts with an empty data path. In the interview, mention that the elected master maintains the cluster state and that elections need a majority of voting nodes.
2. What is a voting-only node and when would you add one?
A voting-only node has the roles [ master, voting_only ]. It takes part in master elections and can break ties, but it can never become the elected master. It is useful when you have two zones with full master nodes and want a cheap tiebreaker in a third zone. Because it never carries the master workload, it can run on a small machine.
node.roles: [ master, voting_only ]
3. What does a coordinating-only node do, and when is it worth having?
A node with node.roles: [ ] only routes requests, runs the gather phase of searches, and splits bulk requests across shards. Dedicated coordinators help when large aggregations or heavy bulk traffic would otherwise put memory pressure on data nodes. Elastic notes that too many of them add overhead to the elected master, so add a few behind the load balancer rather than one per client.
4. Which node roles exist in a current cluster?
The roles are master, data, data_content, data_hot, data_warm, data_cold, data_frozen, ingest, ml, remote_cluster_client and transform, plus voting_only as a modifier on master. Do not combine the generic data role with tier roles on the same node, because it takes precedence and fills every tier.
| Role | Typical hardware | Purpose |
|---|---|---|
| master (dedicated) | Small, stable, low latency | Cluster state, elections, shard allocation |
| data_hot | Fast SSD, more CPU | Active writes and recent searches |
| data_warm | Larger, cheaper disks | Read-mostly recent data |
| data_cold | Dense storage | Fully mounted searchable snapshots or rarely queried indices |
| data_frozen | Local cache disk, object storage behind it | Partially mounted searchable snapshots |
| ingest | CPU heavy | Ingest pipelines |
| ml / transform | Memory and CPU | Anomaly detection jobs, transforms |
| coordinating-only | Memory for reductions | Request routing and result merging |
5. What are the data tiers and how does an index move between them?
Elastic has content, hot, warm, cold and frozen tiers. Each index carries the setting index.routing.allocation.include._tier_preference, for example data_warm,data_hot, and the allocator places shards on the first tier in that list that has nodes. ILM changes the preference as an index enters each phase, using the migrate action, which runs automatically in warm and cold phases unless you disable it.
6. What is the difference between fully mounted and partially mounted searchable snapshots?
A fully mounted index copies the whole snapshot onto local disk, so search speed is close to a normal index; ILM uses this in the cold phase and names the index with a restored- prefix. A partially mounted index keeps only recently read parts in a shared cache on frozen nodes and fetches the rest from the repository on demand; ILM uses this in the frozen phase with a partial- prefix. Neither needs replicas by default because the snapshot repository provides the redundancy. Searchable snapshots need an Enterprise license.
7. What is logsdb index mode?
logsdb is an index mode built for log data. You set index.mode: logsdb in an index template, and Elasticsearch stores the data more compactly. Elastic's own benchmarks report up to 60% less storage with a 10 to 20% indexing cost, and they say results vary by data set. In Elastic Stack 9.0 and later it is applied automatically to new logs-*-* data streams; existing streams change only at their next rollover.
8. What is a time series data stream (TSDS)?
A TSDS is a data stream with index.mode: time_series, built for metrics. You mark identifying fields with time_series_dimension: true and measurements with time_series_metric set to counter, gauge or histogram. Elasticsearch builds an internal _tsid from the dimensions, routes all points of one series to the same shard, and rejects a duplicate series and timestamp with a 409. Elastic reports around 70% disk savings in its benchmarks. Use it for metrics, not for logs.
9. What is the data stream failure store?
The failure store is a secondary set of indices inside a data stream that holds documents which failed ingest processing or mapping. The client gets a success response flagged as redirected instead of an error, so one bad document does not drop on the floor. It is GA in Elastic Stack 9.1, enabled by default for logs-*-* through the built-in logs template, and you query it with the ::failures selector, for example FROM logs-app-default::failures in ES|QL. Reading it needs the read_failure_store privilege because failed documents keep their raw, possibly sensitive content.
10. Which mapping field types matter most at scale?
keywordfor exact values, sorting and aggregations.match_only_textfor log messages where you need full text search but not scoring or phrase positions at full cost.wildcardfor high-cardinality strings searched with wildcards or regex, such as URLs.flattenedfor objects with many unpredictable keys, mapped as one field.constant_keywordfor a value that is the same in every document of an index, such as a data stream dataset.
Knowing when each one saves heap and disk is what separates an architect answer from a definition.
Intermediate design questions (2 to 5 years)
11. How do you make a cluster survive the loss of an availability zone?
Tag each node with its zone, for example node.attr.zone: zone-a, and enable shard allocation awareness with cluster.routing.allocation.awareness.attributes: zone. Elasticsearch then keeps a primary and its replica in different zones. Spread three master-eligible nodes across three zones, or two full masters plus a voting-only tiebreaker. Make sure each zone has enough disk to hold the extra copies when another zone is down.
12. What is forced awareness and why would you use it?
With plain awareness, if one zone fails, Elasticsearch rebuilds all missing replicas in the surviving zone, which can overload it. Forced awareness, set with cluster.routing.allocation.awareness.force.zone.values: zone-a,zone-b, tells the cluster that both zones should exist, so it leaves replicas unassigned instead of doubling up. You accept yellow health during the outage in exchange for not filling the surviving zone's disks.
13. How do you stop one node from taking too many shards of a busy index?
Set index.routing.allocation.total_shards_per_node on the index or in its template. For a hot write index with, say, four primaries and one replica on eight hot nodes, a limit of 1 spreads indexing evenly. Set it too low and shards stay unassigned when a node leaves, so leave headroom.
14. How do you choose between a standard data stream, logsdb and a TSDS?
| Data | Choice | Why |
|---|---|---|
| Application and system logs | Data stream with logsdb | Smaller storage, sorted for time and host filtering |
| Metrics with clear dimensions | TSDS | Series routing, dedupe, downsampling, large disk savings |
| Security events with frequent updates | Standard indices or data stream with care | Data streams are append-only; updates need the backing index |
| Reference or catalog data | Regular index behind an alias | Updates and deletes by ID are normal |
15. Which ILM actions do you use beyond rollover and delete?
In warm: shrink to cut shard count, forcemerge to reduce segments, allocate to change replicas, readonly and set_priority for recovery order. In cold and frozen: searchable_snapshot. For TSDS: downsample to keep a coarser version of old metrics. Explain each choice in terms of what it saves: shards, heap, disk or recovery time.
16. What does shrink require, and when do you use split instead?
Shrink makes an index with fewer primaries, and the target count must be a factor of the source count. The source must be read-only and have a copy of every shard on one node. Split goes the other way, to a multiple of the current primaries. In a logging platform, shrink after rollover is common; split is rare because rollover already lets you change shard count for new indices.
17. How does index sorting help log workloads?
Index sorting (index.sort.field and index.sort.order) stores documents on disk in a chosen order, such as by host then timestamp. Similar values sit together, so compression improves, and queries that sort by the same fields can stop early. The cost is slower indexing. logsdb applies a sort for you, and TSDS sorts internally by _tsid and @timestamp, so index.sort.* does not apply there.
18. How do you control dynamic mapping on a large shared platform?
Set dynamic: strict where schemas are owned, so unknown fields fail fast; dynamic: false to keep unknown fields in _source without indexing them; or dynamic: runtime so new fields become runtime fields with no index cost. Combine this with dynamic templates that map strings to keyword by default and with the index.mapping.total_fields.limit setting, which defaults to 1000.
19. When are runtime fields the right answer?
Runtime fields are computed at query time from _source or other fields. Use them to fix a wrong mapping without reindexing, to add a field for an investigation, or for rarely queried fields that you do not want to pay index and heap for. They are slower than indexed fields on large ranges, so promote heavily used ones to real fields at the next rollover.
20. What is an enrich processor and how do you design around it?
The enrich processor adds data from a source index to incoming documents, for example owner and cost centre by hostname. You define an enrich policy (match, range or geo_match), execute it to build a system enrich index, and reference the policy in an ingest pipeline. The enrich index is a snapshot of the source, so you must re-execute the policy when reference data changes. Keep the source small and the match field exact.
PUT /_enrich/policy/host-owner
{
"match": {
"indices": "cmdb-hosts",
"match_field": "host.name",
"enrich_fields": ["owner.team", "cost_centre"]
}
}
POST /_enrich/policy/host-owner/_execute
21. What are default_pipeline and final_pipeline?
index.default_pipeline runs when a request names no pipeline, and a request can override it. index.final_pipeline always runs last, after any request or default pipeline, and cannot be skipped by the client. Platform teams use the final pipeline for rules that must apply to everyone, such as masking or adding an ingest timestamp.
22. What does the reroute processor do?
The reroute processor sends a document to a different data stream from inside an ingest pipeline, usually by changing the dataset or namespace part of the name. A common pattern is one generic input stream, such as Kubernetes container logs, that reroutes each document to logs-<app>-<namespace> based on a field, so each app gets its own retention and permissions.
23. How do you design ingest pipeline failure handling?
Add on_failure at processor level for expected problems, such as a date that sometimes has another format, and at pipeline level as a catch-all that records the error message. On 9.1 and later, enable the failure store so documents that still fail are kept and searchable. Test changes with the simulate API and watch per-processor stats in the nodes stats API.
24. How do snapshots work, and what makes a repository production ready?
Snapshots are incremental at the segment level: a new snapshot copies only segment files the repository does not already have. Supported repository types include S3, Google Cloud Storage, Azure Blob Storage, HDFS, shared filesystems and read-only URL repositories. Before trusting one, run the repository analysis API, which tests read, write and consistency behaviour. Automate with snapshot lifecycle management (SLM) policies that set schedule and retention.
25. How do you secure traffic between clusters for CCS and CCR?
Current versions offer the API key based remote cluster security model, where the remote cluster exposes a separate remote cluster server interface and the local cluster authenticates with a cross-cluster API key that limits which indices it can search or replicate. The older certificate based model relies on TLS trust between transport layers and matching roles on both sides. For new designs, prefer the API key model because access is scoped per connection.
26. How do you run several Kibana instances for availability?
Put two or more Kibana instances behind a load balancer pointing at the same Elasticsearch cluster. Give them the same xpack.encryptedSavedObjects.encryptionKey, xpack.security.encryptionKey and xpack.reporting.encryptionKey, otherwise saved objects, sessions and reports created on one instance break on another. Kibana's task manager spreads background work such as alerting rules across instances.
Senior and architect questions
27. How do you size a cluster from first principles?
Start with daily raw volume, expected size on disk after indexing (measure it with a sample, since logsdb and mappings change it a lot), replica count, and days in each tier. Total storage per tier is daily size times days times (1 + replicas), plus disk watermark headroom. Then derive shard counts from the 10 GB to 50 GB guidance and check the 1000 non-frozen shards per node limit. Validate indexing rate and query latency with a load test using your own data; Elastic's Rally tool is built for this.
28. Why does Elastic recommend 10 GB to 50 GB shards, and when do you break that rule?
Each shard has fixed overhead in heap, file handles and cluster state, so many tiny shards waste resources. Very large shards recover and relocate slowly. The range is a balance for typical logs and search. You might go smaller for a search use case that needs many parallel shards for latency, or keep a single small shard for a tiny index rather than splitting it. Also keep each shard under 200 million documents.
29. How much heap do master nodes need, and what drives it?
Master heap grows with the size of the cluster state: indices, shards and especially mapped fields. Elastic gives a rule of thumb of about 1 GB of master heap per 3000 indices. Field count adds overhead on every node, so a few indices with tens of thousands of fields can hurt more than many simple ones. Use the cluster stats API to see total field counts.
30. One cluster or many? How do you decide?
Split when blast radius, compliance, upgrade cadence or tenant isolation matter more than shared operations. Common splits are per region (data residency), per environment, or a separate security analytics cluster. Cross-cluster search then gives a single query view in Kibana. Keep one cluster when teams share data heavily and the cluster stays well inside shard and state limits.
31. How would you design cross-cluster replication for disaster recovery?
CCR is active-passive: writes go to the leader index and followers are read-only copies that pull operations from the leader. Configure the remote cluster connection, then auto-follow patterns so every new backing index of a data stream is followed. Point clients only at the primary site. On failover, stop following and convert followers to normal indices, then redirect writes. Replication is asynchronous, so the recovery point is not zero; state that clearly to stakeholders.
32. When is cross-cluster search better than replication?
Use CCS when data can stay where it is produced and you only need to query it together, for example regional clusters with a central Kibana. It avoids copying storage and keeps residency simple. Use CCR when you need a local, fast or always available copy, such as for disaster recovery or read locality. With CCS, ccs_minimize_roundtrips (default true) lets each remote cluster reduce its own results, which matters over high latency links.
33. How do you design multi-tenancy?
Options, from strongest to lightest isolation: a cluster per tenant; data streams per tenant using the namespace part of the name, with roles granting logs-*-tenant_a; or shared indices with document-level security filtering by a tenant field. Combine with Kibana spaces for saved objects. Per-tenant data streams give separate retention and simpler deletes, at the cost of more shards, so set a minimum tenant size before giving one its own streams.
34. What would you audit, and how?
Enable security audit logging with xpack.security.audit.enabled: true on each node and ship the audit log to a separate, restricted cluster or data stream. Filter noisy events with audit event include and exclude settings. Record authentication failures, access denials, role and user changes, and index deletions. Audit logging needs a paid subscription level, so check the Elastic subscriptions page for your version.
35. How do you find a slow query in a large cluster?
Turn on search slow logs per index with thresholds, use the profile API on the query to see which part is expensive, and check the Tasks API for long-running searches. Common causes are leading wildcards on keyword fields (move to the wildcard type), large terms aggregations on high-cardinality fields, scripts, deep pagination with from and size (use search_after with a point in time), and queries that hit every backing index because the time filter is missing.
36. How do caches help search, and how can you make them work for you?
The shard request cache stores results of requests with size: 0, such as dashboard aggregations, and is invalidated on refresh. The node query cache stores filter results. Kibana dashboards benefit when time ranges are rounded, because identical requests can hit the request cache. Read-only warm indices are good cache candidates since they no longer refresh with new data.
37. What are circuit breakers, and what do you do when they trip?
Circuit breakers stop a request before it uses enough memory to destabilise a node, returning an error instead. The parent breaker tracks total usage, with child breakers for field data and in-flight requests. When they trip, look for the query that caused it: huge aggregations, fielddata on text fields, or very large bulk requests. Fix the request or the mapping first; raising breaker limits usually moves the crash elsewhere.
38. How do you tune bulk indexing at architect level?
- Find the best bulk request size by testing, increasing until throughput stops rising.
- Use several client workers so all hot nodes stay busy.
- For one-off loads, set
refresh_intervalto-1and replicas to 0, then restore them. - Spread primaries across hot nodes and avoid hot spots with
total_shards_per_node. - Watch the write thread pool rejections; repeated 429 responses mean the cluster is the bottleneck.
39. How do you plan a storage cost reduction without losing data?
In order of effort: drop unused fields at ingest; move log streams to logsdb; set index.codec: best_compression on warm data; shorten hot retention and move data to cold or frozen searchable snapshots; downsample old metrics in TSDS; and review replica counts on tiers backed by snapshots. Measure before and after each change on real data.
40. Where do Logstash and Elastic Agent fit in a modern architecture?
Elastic Agent, managed by Fleet, collects data with integrations that ship their own ingest pipelines and dashboards. Logstash stays useful when you need complex routing to several outputs, buffering with persistent queues at a site edge, or inputs Agent does not cover. Agent can send to Logstash as an output. The architect answer is to keep parsing in one place per data source so logic is not split between Logstash and ingest pipelines.
41. How do you handle an Elasticsearch major upgrade on a large estate?
Run the Upgrade Assistant in Kibana to find deprecated settings and old indices, take a fresh snapshot, then upgrade in Elastic's documented order: Elasticsearch before Kibana, and agents or Beats after the stack. Do a rolling upgrade where the versions allow it. Upgrade remote clusters with CCS and CCR compatibility rules in mind, checking the version compatibility table before you start.
42. Elasticsearch, OpenSearch or a managed service: how do you frame that choice?
Compare features you actually need (for example logsdb, ES|QL, searchable snapshots, security model), licence terms, team skills, and who carries operations. Elastic offers self-managed, Elastic Cloud Hosted and Serverless. OpenSearch is a separate fork with its own feature set. Avoid claiming one is faster in general; ask for a test on your own data.
Design scenarios
43. Design a logging platform for 2 TB of raw logs a day with 14 days hot, 90 days searchable and one year retained.
Measure the indexed size per GB of raw logs on a sample with logsdb. Put logs in data streams with an ILM policy: hot with rollover at around 50 GB per primary shard or one day, warm optional, cold or frozen as searchable snapshots until day 90, and delete at day 365, or keep only snapshots in the repository after day 90 if search is not needed. Use three dedicated masters across zones, hot nodes with SSD sized for 14 days times replicas, and frozen nodes with a cache sized for the expected investigation window. Show the storage calculation per tier.
44. Two regions must keep data local by law, but the SOC wants one view.
Run one cluster per region and keep ingest local. Set up a central Kibana on a small cluster that queries both regions through cross-cluster search with cross-cluster API keys limited to read access on the needed data streams. Data never leaves its region at rest. Document what query results cross the border, since search results still travel to the central cluster.
45. A noisy tenant's mapping keeps growing past the field limit and blocks others.
Give the tenant its own data stream through the reroute processor so its mapping is separate. In its template, map the free-form payload as flattened or set dynamic: runtime, and keep strict mappings for shared ECS fields. Failed documents land in the failure store instead of being dropped. Agree a schema contract with the tenant for fields they need to aggregate on.
46. The frozen tier makes old searches too slow for auditors.
Check cache hit rates and whether queries scan every index because of wide time ranges. Size the shared cache (xpack.searchable.snapshot.shared_cache.size) for the working set, narrow queries with time filters, and use async search so long queries do not time out in the browser. If auditors need a fixed period fast, keep that range in the cold tier fully mounted instead.
47. You must recover from losing the primary data centre within an hour.
Run a second cluster in the other site with CCR auto-follow on all critical data streams and SLM snapshots to a repository reachable from both sites. Keep Kibana saved objects exported or replicated, and agent outputs configurable by DNS. Practise the failover: stop following, promote followers, switch DNS for ingest and Kibana. Measure the lag CCR shows to state the real data loss window.
48. Indexing rate doubles every Black Friday for six hours.
Absorb the spike with a buffer such as Kafka or Logstash persistent queues, and scale hot nodes before the event. Lower rollover size so new indices spread over the added nodes, raise refresh_interval on high-volume streams, and pause non-urgent jobs such as force merges and transforms. After the event, let ILM move data on and remove the extra nodes once shards relocate.
49. Design metrics storage for 50,000 hosts with 13 months of history.
Use TSDS with host and metric dimensions, keep raw data hot for a few days, downsample to coarser intervals in warm and cold phases, and move older data to searchable snapshots. Watch the cardinality of dimensions, since each unique combination is a series. Compare against a dedicated metrics system if the team already runs Prometheus, and explain the trade-off; our Prometheus and Grafana guide covers that side.
50. Security wants PII masked, but engineers need raw logs for 24 hours.
Write two copies only if you must; a cleaner design is masking in a final_pipeline for the shared stream, and a short-lived restricted stream for raw data with a one-day delete phase and field-level security. Grant raw access through a role only on-call engineers hold, and audit reads. Check the legal basis for even 24 hours of raw storage with the data owner.
51. The cluster has 30,000 shards and the master is struggling.
Find small indices with the cat indices API sorted by size. Raise rollover size so new indices are larger, shrink warm indices, merge tiny daily indices into data streams or monthly indices with reindex, delete expired data, and move old data to frozen, where the per-node shard limit is higher (3000). Use dedicated masters with enough heap while you clean up, and set a review so shard growth does not return.
52. Kibana alerting rules run late across hundreds of rules.
Check Kibana task manager health through its health API and see whether rules are overdue. Add Kibana instances so task manager can spread work, lengthen intervals for rules that do not need minute-level checks, and make rule queries cheaper with narrow time windows and keyword fields. Confirm Elasticsearch is not rejecting searches during peaks.
How to answer advanced ELK questions well
- Start with requirements: volume, retention, query patterns, recovery point and recovery time.
- Name the trade-off for each choice: cost, latency, failure behaviour.
- Give numbers where Elastic publishes them and say "measure on our data" where it does not.
- Close with how you would monitor the design, such as stack monitoring, ILM errors and failure store growth.
If you want guided practice on these designs with labs, our ELK Stack training in Pune runs in the Kharadi classroom and live online across India. Teams pairing logs with metrics can also look at the Prometheus and Grafana course. For broader interview preparation, see the 200+ DevOps interview questions hub.
FAQ
What counts as an advanced ELK Stack interview question?
One that asks you to design or justify, not define: node role layout, shard and tier sizing, data stream type choice, cross-cluster design, security between clusters, and tuning under load. This page has 52 such questions grouped by level plus scenarios.
What is logsdb in Elasticsearch?
An index mode for logs that stores data more compactly. It is GA in Elastic Stack 9.0 and applied automatically to new logs-*-* data streams; Elastic reports up to 60% storage savings in its benchmarks, varying by data set.
When should I use a time series data stream?
For metrics with clear dimensions arriving in timestamp order. TSDS routes each series to one shard, rejects duplicates and supports downsampling. Use logs data streams for logs and traces.
What is the difference between CCR and CCS?
Cross-cluster replication copies indices from a leader to read-only followers in another cluster, active-passive. Cross-cluster search queries remote clusters in place without copying data.
Do searchable snapshots need a paid licence?
Yes. Elastic's documentation states that searchable snapshots require an Enterprise license. They power the cold and frozen tiers.
What shard size does Elastic recommend?
Between 10 GB and 50 GB per shard, with fewer than 200 million documents per shard, and no more than 1000 non-frozen shards per node.
What is the failure store?
A set of indices inside a data stream that keeps documents which failed ingest, so they are not lost. It is GA in Elastic Stack 9.1 and queried with the ::failures selector.
How is this page different from the other ELK interview guides?
The main guide covers core concepts, the fresher page covers commands, the real-time page covers latency and streaming, and the engineer page covers operations. This page covers architecture and design decisions.
Official references
What's Your Reaction?
Like
0
Dislike
0
Love
0
Funny
0
Angry
0
Sad
0
Wow
0