Event-Driven

Event-Driven Architecture with SQL

Build event-driven systems using standard SQL instead of complex event processing frameworks. RisingWave transforms event streams into queryable state, enabling real-time reactions, materialized views, and downstream notifications.

Start Free Use Cases

SQL

No Framework Code

Replace Java event processors with declarative SQL. Define event logic as materialized views.

Kafka

Native Integration

Connect to Kafka, Pulsar, and Kinesis as both sources and sinks for bidirectional event flows.

CQRS

Pattern Support

Built-in support for CQRS, event sourcing projections, saga coordination, and event correlation.

Exactly-Once

Event Consistency

Exactly-once semantics across the entire event processing pipeline, from source to sink.

Architecture

What is event-driven architecture and why is it gaining adoption?

Event-driven architecture (EDA) is a design paradigm where system components communicate through events — immutable records of state changes. EDA enables loose coupling, real-time responsiveness, and scalable distributed systems. Adoption is accelerating as businesses demand instant reactions to customer actions, IoT signals, and operational changes.

Loose Coupling

Producers and consumers operate independently, enabling teams to evolve services without cascading changes.

Real-Time Responsiveness

Events are processed as they occur, eliminating batch delays and enabling sub-second reaction times.

Scalable by Design

Event streams can be partitioned and processed in parallel, scaling horizontally with data volume.

Auditability

Immutable event logs provide a complete history of every state change for compliance and debugging.

How It Works

How does RisingWave simplify event-driven systems with SQL?

RisingWave replaces custom event processing code with declarative SQL. Instead of writing Java consumers, managing state stores, and building serving layers, teams define materialized views over event streams. RisingWave continuously maintains these views and makes results queryable — turning complex EDA pipelines into simple SQL statements.

→Ingest events from Kafka, Pulsar, Kinesis, and other message brokers using CREATE SOURCE
→Define streaming computations as materialized views with standard SQL JOINs and aggregations
→Query event-derived state directly via PostgreSQL-compatible connections
→Push processed events to downstream systems using CREATE SINK for real-time reactions
→Maintain exactly-once consistency across the entire event processing pipeline

Patterns

What event-driven patterns does RisingWave support?

RisingWave supports core event-driven patterns including CQRS, event sourcing projections, saga coordination views, and real-time event aggregation. By expressing these patterns in SQL, teams avoid the complexity of custom framework code while maintaining the architectural benefits of event-driven design.

→CQRS — maintain read-optimized materialized views from event streams, separating write and read models with automatic incremental updates
→Event Sourcing Projections — build queryable projections from append-only event logs, continuously deriving current state from historical events
→Saga Coordination — monitor distributed transaction progress by joining events across services, detecting failures and compensation triggers in real time
→Event Aggregation and Correlation — combine events from multiple streams using temporal joins and window functions to detect patterns and anomalies

Frequently Asked Questions

Can RisingWave replace my event processing framework?

How does RisingWave integrate with Kafka for event-driven architecture?

Does RisingWave support complex event processing (CEP)?

Can I trigger actions based on streaming query results?

Ready to build event-driven systems?

Replace complex event processing code with SQL in minutes.

Build Event-Driven Systems with SQL

Streaming ETL →Exactly-Once Streaming →