Elasticsearch Team Development Constitution: Principles and Guidelines for Sustainable Software Development

As core developers of Elasticsearch, we aim to evolve the system into a reliable, robust, secure, scalable, and easy‑to‑use platform while fostering innovation, removing fragile code, and improving user experience despite rapid growth.

Consensus on the team’s direction is crucial; we emphasize why we choose specific paths. Early Elasticsearch offered limitless flexibility, ease of use, and a rich API, but rapid user growth outpaced support capacity, exposing risks such as remote code execution via scripts and overly permissive settings.

Today, with a much larger user base, we have tightened boundaries: stricter input validation, fine‑grained permission models, and a plugin architecture that balances flexibility with risk.

Nevertheless, many challenges remain—e.g., aggregation requests that can overload servers, large heap usage, and an overwhelming number of boolean options.

We bear a huge responsibility to provide a reliable, robust, secure, and user‑friendly system, and we must innovate quickly while maintaining stability.

Design Principles

Process over outcome: prioritize incremental, well‑tested changes rather than massive, risky rewrites.

Design for today, use abstraction cautiously: avoid premature or excessive abstraction that can hinder performance and maintainability.

Start simple; avoid cleverness: implement new features in the simplest way possible before adding complexity.

Removing code is hard: be deliberate when adding features, as future removal may be costly.

Strict, explicit, reliable, simple: prefer clear, well‑tested options over numerous ambiguous configurations.

Stay within core responsibilities: focus on distributed search capabilities and discard unrelated components.

Act as experts: design APIs that are easy to use and hard to misuse, preventing performance degradation and errors.

Build features as isolated plugins rather than core additions to preserve a lean core.

Remove before fixing dangerous features: prioritize removal of risky functionality, even if it means temporary loss of capability.

Default fast, slow optional: disable performance‑heavy features by default and require explicit opt‑in.

Prioritize upgrade experience: ensure smooth, fast upgrades to minimize cluster downtime.

Break major, not minor, versions: reserve breaking changes for major releases.

Bottom‑up testing: write extensive unit tests first, followed by integration tests.

Consider Java API as expert API: keep internal APIs private and expose stable REST interfaces to users.

Question all code and embrace errors: document rationale, anticipate short code lifespans, and handle failures gracefully.

Never fear major changes: be willing to make large, necessary changes when incremental updates are insufficient.

Say no when necessary: reject changes that do not align with Elasticsearch’s core goals.

Accept only scalable features: reject single‑node‑only requests that conflict with distributed design.

Start from the ideal solution: aim for the simplest, most elegant design even if it requires later refinement.

Focus on good error reporting: fail fast, provide clear messages, and avoid swallowing exceptions.

Provide documentation for code: maintain high‑level overviews at package, class, and method levels.

Default to private: keep APIs private unless public exposure is absolutely required.

Every change deserves review: require at least one (often two) approvals for each modification.

Dare to break rules when justified: sometimes breaking conventions leads to clearer code.

Interaction with People

Express opinions precisely and respectfully, providing reasoning rather than commands.

Stay friendly: assume good intent, apologize for misunderstandings, and communicate clearly.

Show appreciation: acknowledge good work with specific, sincere feedback.

Use veto power responsibly: only exercise a veto when you are certain a change is harmful.

Explain opposition with technical reasons and be open to discussion.

Value passion but manage patience; encourage face‑to‑face discussions for complex debates.

Empathize with stress and handle aggressive comments by reporting abuse.

Ask questions when uncertain; seek help to resolve complex issues.

Resolve conflicts through dialogue, accept decisions, and move forward.

Inspirations

Zen of Python

Contributor Covenant

Amazon’s Leadership Principles

Rust’s Code of Conduct