Elasticsearch vs. OpenSearch in Practice

Elasticsearch / OpenSearch

Chapter 9 · Elasticsearch vs. OpenSearch in Practice

search1-2 deliberately deferred a real verdict to this chapter. Here it is — as honestly as the still-evolving nature of the situation allows.

Where the Two Projects Still Agree

The core REST API surface remains largely compatible for basic operations — indexing documents, basic search, basic aggregations — a real, practical consequence of both projects sharing the same starting codebase (search1-2's own "last Apache-licensed version" fork point). Many client libraries and tools can work against either engine for common, basic operations with little or no modification.

Where They've Genuinely Diverged

Since the fork, each project has developed its own features independently, on separate release cycles, without the other — over time, this means some newer functionality genuinely exists in only one of the two, not both. Newer, added products have diverged in naming and branding too: OpenSearch Dashboards is a separate, independently-developed product built specifically for OpenSearch, not a shared or interchangeable tool with Kibana, even though the two started from a shared ancestor per search1-2. Version numbering has diverged independently as well — Elasticsearch and OpenSearch version numbers no longer correspond to each other at all; they're two separate projects with their own independent numbering, not the same underlying version wearing two labels.

This chapter deliberately avoids listing specific, dated feature comparisons as if they were permanently true — matching search1-2's own "still-evolving" honesty. The durable guidance is to check current, up-to-date documentation for whichever specific feature actually matters to a real project.

Licensing Implications for a Real Deployment Decision

This is a direct callback to search1-2's own full licensing history: Elasticsearch's own licensing (Elastic License/SSPL, with AGPL added back as an option in 2024) versus OpenSearch's own licensing — OpenSearch has remained genuinely, fully open-source under Apache 2.0 since its own creation. This is a real, concrete decision point: does a specific deployment genuinely require or prefer a permissive, unambiguous open-source license (favoring OpenSearch), or is Elastic's own dual/triple-licensed model — with its own specific proprietary features and official commercial support options — actually the better practical fit?

Worth noting honestly: hosted/managed offerings exist for both — Elastic's own official Elastic Cloud, and AWS's own managed OpenSearch Service alongside other third-party managed OpenSearch offerings. This isn't simply "self-hosted vs. vendor-hosted" — both projects have real commercial hosting ecosystems around them.

A Practical Approach to Choosing

Rather than a static "X is better at Y" table that risks going stale quickly (an honest acknowledgment this course itself makes, given how recently and rapidly this situation has evolved), the durable guidance is:

  1. Check the specific licensing terms against the deployment's own real constraints — an open-source requirement, a commercial-support need, or a specific proprietary feature dependency.
  2. Check current, up-to-date documentation for whichever specific feature the project genuinely needs, since API/feature parity is a moving target.
  3. Consider existing team/organizational familiarity and existing tooling compatibility, since both are now genuinely mature, capable options for most common use cases.

The Ecosystem Around Each

Both have real, growing plugin/extension ecosystems, and both integrate with common ingestion and dashboarding tooling. Whatever "ecosystem gap" exists at any given moment is exactly the kind of detail that needs current verification rather than being settled once and treated as permanent.

"Compatible today" is not "interchangeable forever"
Because of the ongoing, independent divergence this chapter covers, a client library, plugin, or piece of tooling written or tested against one of the two engines is not guaranteed to keep working correctly against the other, even if it happens to work today. Genuinely testing against the specific engine and version actually being deployed — rather than assuming interchangeability based on shared ancestry — is the responsible practice.
search1-2's own history, now made practical
Every fact from search1-2's own history chapter now has a real, concrete practical consequence here. search1-10's own decision-framework chapter turns the whole course's own material — not just this specific Elasticsearch-vs-OpenSearch question — into one honest, usable framework.

Hands-On Exercises

Exercise 1

Explain why the core REST API remains largely compatible between the two engines for basic operations, tying your answer back to search1-2's own fork material, and explain why this compatibility isn't guaranteed to remain complete or permanent.

📄 View solution
Exercise 2

Explain the real licensing implications this chapter draws for an actual deployment decision — what's the concrete difference between Elasticsearch's own licensing model and OpenSearch's, and what kind of deployment constraint would favor each?

📄 View solution
Exercise 3

Using this chapter's own warn-box, explain why "compatible today" isn't the same as "interchangeable forever," and explain the responsible practice this chapter recommends instead of assuming interchangeability.

📄 View solution

Chapter 9 Quick Reference

  • Basic REST API operations remain largely compatible — a direct consequence of the shared fork point (search1-2)
  • Independent development since the fork means genuine, growing divergence in features, product naming (Kibana vs. OpenSearch Dashboards), and version numbering
  • Licensing: Elasticsearch's own Elastic License/SSPL/AGPL vs. OpenSearch's own consistent Apache 2.0 — a real, concrete deployment constraint to check
  • Both have real commercial hosting ecosystems — not simply "self-hosted vs. vendor-hosted"
  • Durable guidance: check licensing against real constraints, check current docs for specific features, weigh team familiarity — not a static comparison table
  • Compatible today ≠ interchangeable forever — test against the specific engine/version actually deployed
  • Next chapter: When to Reach for a Dedicated Search Engine