Open-Source Observability · pubkey

event-reduce

Event-Reduce is an algorithm that optimizes how applications handle database query results when data changes. Instead of re-running expensive queries, it intelligently applies incoming change events to cached results, achieving up to 12x faster updates with minimal CPU overhead.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/pubkey/event-reduce

755

GitHub stars

Forks

TypeScript

Primary language

MIT

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	pubkey/event-reduce
Owner	pubkey
Primary language	TypeScript
License	MIT — OSI-approved
Stars	755
Forks	23
Open issues	9
Latest release	5.1.0 (2023-12-12)
Last updated	2026-07-08
Source	https://github.com/pubkey/event-reduce

What event-reduce is

Event-Reduce uses a decision-tree (binary decision diagram) derived from 2^19 state-action combinations to determine how incoming database events modify existing query results without re-execution. It works by evaluating 18 state functions (isInsert, wasResultsEmpty, sortParamsChanged, etc.) against events and applying corresponding action functions (insertFirst, replaceExisting, insertAtSortPosition) to maintain query consistency.

Quickstart

Get the event-reduce source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/pubkey/event-reduce.git2cd event-reduce3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Real-time Collaborative Applications

Applications requiring sub-100ms latency updates when multiple users modify shared data (e.g., collaborative editing, live dashboards). Event-Reduce reduces the latency of displaying query result changes after a write by computing updates on-CPU rather than re-querying the database.

High-Scalability Backend Query Streaming

Backend systems streaming query result deltas to many concurrent clients with different active queries. Event-Reduce reduces bandwidth and disk-IO by computing result changes server-side before transmission, avoiding the need to materialize views for every unique query variant.

Cache Layer Optimization for NoSQL Databases

Applications using MongoDB, CouchDB, or similar databases where cache invalidation is expensive. Event-Reduce maintains cache freshness by predictably applying change events instead of invalidating on writes, improving hit rates and reducing database load.

Implementation considerations

Current JavaScript/TypeScript implementation only; adopting Event-Reduce for other languages requires porting the optimized BDD or implementing the algorithm from scratch.
Ensure your database change events are delivered reliably and in order; missing or misordered events will silently corrupt cached query results.
Query results must be sortable deterministically; if not, augment sort keys with primary key or unique identifiers before using Event-Reduce.
State functions evaluate incoming events against cached results; ensure events include sufficient metadata (document ID, field changes) to match state conditions.
Benchmark with your actual query patterns and event frequency; Event-Reduce overhead may not justify cost if queries are infrequent or event bursts are rare.

When to avoid it — and what to weigh

Unpredictable or Non-Deterministic Query Sort Order — Event-Reduce requires queries to have deterministic, predictable sort order for any given set of documents. If your queries use non-deterministic sorting or collation, the algorithm cannot guarantee correctness without adding the primary key as a tiebreaker.
Complex Relational Queries Across Multiple Tables — Event-Reduce is designed for single-collection/table queries. Relational queries spanning multiple tables are not supported (workarounds like database views exist but add complexity). The optimization computation itself is NP-hard for expanded state spaces.
Applications Without Native Change Event Streams — Event-Reduce requires an upstream system (oplog, CDC, event log) that reliably emits write events. If your database does not provide structured change events, you must build that infrastructure first, increasing overall complexity.
Write-Heavy Workloads With Low Read Reuse — If the same query is rarely executed multiple times before being invalidated, the overhead of Event-Reduce decision evaluation outweighs the benefit of skipping re-execution. Best suited to scenarios with high query repetition and moderate write rates.

License & commercial use

Licensed under MIT (MIT License), a permissive OSI-approved license.

MIT license permits commercial use, modification, and distribution with attribution. No patent grants or indemnification clauses present. Suitable for proprietary commercial software; review your legal standards for attribution compliance in binaries or bundled distributions.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Adequate
License clarity	Clear
Deployment complexity	Low
DEV.co fit	Good
Assessment confidence	High

Security considerations

Event-Reduce is a stateless algorithmic library with no network, authentication, or encryption concerns. Security relies entirely on upstream change event integrity: if an attacker can inject or modify events, cached results will be corrupted silently. Ensure change event source is authenticated and tamper-proof. No known CVEs or security advisories in provided data.

Alternatives to consider

Materialized Views (PostgreSQL, MongoDB, etc.)

Solve similar problem by pre-computing and maintaining views on write. Trade-off: scales poorly with many unique queries and impacts write latency. Event-Reduce computes on read, avoiding write-time cost.

Meteor OplogDriver

Predecessor optimized for MongoDB oplog, but limited to queries without skip or sort. Event-Reduce handles arbitrary sort, skip, and filter combinations with higher coverage (~94% event optimization vs. OplogDriver's subset).

RxDB QueryChangeDetection (legacy) or Fresh Query Re-execution

RxDB's old approach used handwritten if-else logic for change merging; now replaced by Event-Reduce in RxDB 9.0+. Full re-execution is simple but incurs disk-IO cost (100ms per query in example vs. near-instant with Event-Reduce).

Software development agency

Build on event-reduce with DEV.co software developers

Event-Reduce can slash latency in real-time applications and reduce database load by intelligently applying change events to cached results. Our engineers can help you integrate Event-Reduce into your backend or evaluate it against your query patterns. Contact us to discuss your use case.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

FASTER ekuiper versus-incident

Related on DEV.co

Explore the category and the services that help you build with it.

Open-Source Observability API Development Web App Development Custom Software Development Talk to DEV.co

event-reduce FAQ

Does Event-Reduce require changes to my database schema or queries?

No. Event-Reduce is agnostic to schema and works with any database supporting change event streams. Only requirement: queries must have deterministic sort order. If not, add primary key as tiebreaker.

What if I miss or receive an out-of-order change event?

Event-Reduce assumes events are delivered reliably and in causal order. Missed or misordered events will silently corrupt cached results. You must guarantee event stream reliability upstream, or fall back to full re-execution on gaps.

Can I use Event-Reduce with SQL queries spanning multiple tables?

Not directly. Event-Reduce is single-collection/table only. Workaround: materialize multi-table results as a view and query the view. True multi-table optimization is theoretically possible but computationally expensive (NP-hard state space).

How much overhead does Event-Reduce add if queries are infrequent?

If a query runs only once before data changes, Event-Reduce decision evaluation (~1-10ms) adds latency with no benefit. Event-Reduce is cost-effective only when the same query runs multiple times, allowing reuse to amortize the decision cost.

Software developers & web developers for hire

DEV.co is a software development agency delivering custom software development services to companies building on open source. Our software developers and web developers design, integrate, and ship production systems — spanning web development, APIs, AI, data, and cloud. If event-reduce is part of your open-source observability roadmap, our team can implement, customize, migrate, and maintain it.

Ready to Optimize Your Query Performance?

Talk to DEV.co Schedule a Consultation