Elasticsearch

Elasticsearch delivers full-text search, faceting, and analytics at scale from a distributed index. I use it to power product search and to analyse logs and metrics with Kibana, so operational and user-facing search live in one engine.

Index mapping and tokenisation are where search quality is won: analyzers, field types, and relevance tuning (scoring, boosting, filters) turn a raw index into results users actually want. I pair it with the other stores rather than replace them.

Operations revolve around cluster health, shard sizing, and index lifecycle management — rolling over and pruning indices so the cluster stays fast and its storage stays bounded.

Search quality lives in the mapping. I design field types and analyzers deliberately — what gets tokenised, how, and what stays exact — because relevance is decided upstream of the query, in how well the index reflects the language of the content.

Relevance tuning is explicit engineering. Scoring, boosting, and filters compose into queries that surface the right results, and I validate rankings against representative queries instead of trusting that more matches means better matches.

Faceting and aggregations make the data navigable at scale. When a catalogue or dataset needs counts, filters, and breakdowns, I run them against the index rather than dragging documents into the application layer.

The same engine serves observability. Kibana turns logs and metrics into searchable, visualisable operational data, so user-facing search and internal analytics share one dependable, well-sharded foundation.

Operations are about health and lifecycle. I keep the cluster healthy with right-sized shards, roll over indices, and prune history so storage stays bounded and queries stay fast as the data grows in.

Elasticsearch complements the transactional store rather than replacing it. I pair a search index beside a source-of-truth database — indexing what users search and keep the authoritative state in the engine that owns it.

I design the mapping before I index. Field types and analyzers decide what gets tokenised and how, so relevance is set upstream of the query.

Relevance is engineered, not left to the default. Scoring, boosting, and filters compose into queries, and I validate rankings against representative queries rather than trusting raw match counts.

Faceting and aggregations run in the index. Grouping, filtering, and breakdowns happen database-side, not by dragging documents into the application.

The same engine serves observability. Kibana turns logs and metrics into searchable, visualisable operational data, so product search and operational analytics share one foundation.

Index lifecycle is managed deliberately. Rolling over indices and pruning history keep storage bounded and queries fast as data grows.

Cluster health and shard sizing are watched. Right-sized shards keep the cluster healthy and the search fast, and I tune them to the actual workload.

The index is a complement, not a replacement. I keep the source of truth in the transactional store and index what users and operators search.

Tokenisation is matched to the content. Analyzers are chosen for the language and shapes the data really has, not a generic default.

Query DSL is kept correct and maintainable, so relevance changes are inspectable and deliberate rather than accumulated magic.