Materialize Alternatives in 2026: When to Switch and When to Stay

Materialize Alternatives in 2026: When to Switch and When to Stay

·

Updated

·

16 min read

Materialize alternatives for streaming SQL in 2026 are RisingWave (Apache 2.0, PostgreSQL compatible), Feldera (MIT, built on the DBSP model), Timeplus Proton (Apache 2.0, ClickHouse-style SQL), Apache Flink SQL paired with a serving store, and ksqlDB for Kafka-only stacks. Whether you should switch depends on four things: whether the Business Source License and license-key model fit your organisation, whether you depend on Materialize's strict serializability, which sources you need, and whether you need vector or Iceberg features. This guide explains what Materialize does well, what each alternative offers, when to switch, when to stay, and when RisingWave is the wrong choice.

This guide is about Materialize the streaming database (materialize.com), not the Materialize CSS framework.

Disclosure. This article is published by RisingWave Labs, the company behind RisingWave, one of the systems discussed here. We do not rank the systems. Each section links to that vendor's documentation and license so you can check our claims. No performance numbers are quoted except a vendor-run benchmark with a published configuration, labelled as such. Facts were last verified on 8 November 2026; earlier versions of this article understated Materialize's source coverage and Iceberg support, and that has been corrected. For a wider comparison see the streaming database comparison hub.

What Materialize built and why it mattered

Materialize was founded in 2019 by Frank McSherry and Arjun Narayan. McSherry had developed Timely Dataflow and Differential Dataflow at Microsoft Research, two systems for maintaining incrementally updated computations over changing data. Materialize put a PostgreSQL-compatible SQL interface on that foundation.

The result answered questions like "how many sessions are active right now" or "what is the fraud rate by payment method" by maintaining the answer continuously rather than computing it on demand. For high-query-volume, freshness-critical use cases this is fundamentally better than hammering a transactional database or refreshing a view on a schedule.

Materialize also bet correctly on PostgreSQL compatibility. psql, Metabase, Grafana, dbt and ordinary drivers work. Teams did not need a new query language.

Those decisions shaped the category, and every system in this article, RisingWave included, benefited from Materialize proving the idea in production.

What Materialize offers today

Before looking at alternatives, here is what Materialize provides as of November 2026, from its documentation.

  • Consistency. Strong consistency is a design centre: queries see a consistent snapshot across views, with strict serializability as the default isolation level. This is the property most often cited by teams who stay.
  • Sources. Native sources for PostgreSQL, MySQL, SQL Server, Kafka, Redpanda and webhooks. MongoDB and other databases arrive through Debezium and Kafka.
  • Sinks. Kafka and Redpanda, and an Apache Iceberg sink with upsert and append modes.
  • SQL. PostgreSQL wire protocol and dialect, with good documentation on idiomatic streaming SQL patterns such as temporal filters with mz_now().
  • Deployment. Materialize Cloud, or self-managed with a license key. The free Community edition has documented resource caps; Enterprise is quoted by sales.
  • License. The Business Source License 1.1. Source-available, not OSI open source. Each release converts to an open license four years after publication. See the license page.
  • Not documented as of November 2026: a vector data type, embedding functions, or an official MCP server.

Why teams evaluate alternatives

The reasons are consistent across the teams we talk to. None is a dealbreaker for everyone.

The license and the license key. Organisations with a policy requiring OSI-approved licenses cannot use Materialize without a commercial agreement. Even teams without such a policy sometimes object to a self-managed deployment that phones home for a license key, or to Community edition caps that force an Enterprise conversation at a size they consider small.

Cost model. Materialize compute is memory driven. Workloads with large state can become expensive, and Enterprise and Cloud pricing is not published.

Source and sink breadth. Materialize's native sources now cover the three most common relational databases, but MongoDB and others still route through Kafka and Debezium. Teams with Kinesis, Pulsar or S3 sources, or who want to read Iceberg tables as a source, look elsewhere.

AI workloads. Vector columns, embedding functions and MCP access matter more in 2026 than in 2019. Materialize does not document them.

Iceberg as the lakehouse centre. Materialize can sink to Iceberg. Teams that want the streaming system to also host the catalog and run compaction, or to read Iceberg as a source, need more.

The alternatives

RisingWave

RisingWave is an open source, PostgreSQL-compatible streaming database. It shares Materialize's core idea, incrementally maintained materialized views served over PostgreSQL protocol, with different choices on state, consistency and license. Documentation is at docs.risingwave.com and the license is Apache 2.0.

Real strengths. Apache 2.0 with no license key, so self-hosting, modifying and embedding are unrestricted. State lives in RisingWave's own storage engine on S3-compatible object storage with stateless compute, so large state is priced as object storage rather than memory. Native CDC for PostgreSQL, MySQL, SQL Server and MongoDB without Debezium, plus Kafka, Pulsar, Kinesis, S3, Google Pub/Sub, MQTT, NATS, webhooks and Iceberg as sources. Apache Iceberg as a sink, as a source, with a hosted REST catalog and compaction. A vector(n) type, HNSW vector indexes, an openai_embedding() function and an official MCP server. A managed option in RisingWave Cloud and BYOC.

Real limitations. RisingWave provides exactly-once processing and snapshot-consistent reads across materialized views, but not Materialize's strict serializability across arbitrary interactive transactions. Vector indexes are in technical preview and currently limited to append-only inputs. Some Materialize idioms, notably temporal filters with mz_now(), have to be re-expressed with watermarks and time windows. The community is younger than Flink's.

Choose RisingWave when you want the Materialize programming model under Apache 2.0, need CDC from MongoDB or sources beyond Kafka and the big three relational databases, want Iceberg managed by the streaming system, or need vector and MCP features, and your correctness requirement is satisfied by exactly-once processing with snapshot-consistent reads.

Feldera

Feldera is an incremental view maintenance engine built on DBSP, a formal model of incremental computation, with SQL on top. The open source edition is MIT licensed; Enterprise adds high availability and support. Documentation is at docs.feldera.com.

Real strengths. A rigorous theoretical foundation, an OSI-approved license, and a fast release cadence. Results are served over HTTP and ad hoc queries. Sources and sinks include Kafka, Debezium-format CDC via Kafka, HTTP and Iceberg connectors.

Real limitations. A younger project with a smaller ecosystem. SQL is Calcite-based rather than PostgreSQL protocol, so existing PostgreSQL tooling does not connect unchanged. CDC from databases goes through Debezium and Kafka rather than native connectors.

Choose Feldera when you want an open source incremental engine with a formal model behind it, your data arrives through Kafka or HTTP, and you are comfortable with a fast-moving project.

Timeplus Proton

Timeplus Proton is a streaming database derived from the ClickHouse engine, licensed Apache 2.0, with Timeplus Enterprise as the commercial offering. Documentation is at docs.timeplus.com.

Real strengths. A single binary that handles streaming and historical queries in ClickHouse-style SQL, which suits observability-style workloads and teams that already think in ClickHouse.

Real limitations. Not PostgreSQL compatible, so the Materialize migration is a dialect change, not a connection string change. Database CDC arrives via Kafka or Enterprise connectors.

Choose Timeplus Proton when your team already lives in ClickHouse SQL and you want streaming and historical analysis in one engine.

Apache Flink is the most capable stream processor available, Apache 2.0 and documented at nightlies.apache.org/flink. It is not a direct Materialize alternative because it has no serving layer. A Flink SQL job writes to a sink; you query the sink.

Real strengths. MATCH_RECOGNIZE and the CEP library, custom operators, fine control over very large keyed state, the largest community, and managed options from Confluent, Ververica, AWS, Decodable and DeltaStream.

Real limitations. Two systems instead of one: Flink plus PostgreSQL, ClickHouse or Iceberg for serving, with connector and schema coordination between them. A SQL dialect with a smaller function library than PostgreSQL. Operational weight: JobManager, TaskManagers, state backends, checkpoints and savepoints.

Choose Flink when you need CEP or custom operators that no streaming database offers, or when your organisation already runs Flink well and the serving store is already in place.

ksqlDB

ksqlDB is Confluent's SQL layer on Kafka Streams, documented at docs.ksqldb.io and licensed under the Confluent Community License, which is not OSI-approved.

Real strengths. SQL over topics with no new cluster for Confluent customers, and pull queries for point lookups.

Real limitations. Kafka in and Kafka out only, so no direct database CDC. A non-PostgreSQL dialect. Restricted joins. Confluent's documentation states that for new stream processing workloads Confluent Platform for Apache Flink is recommended, with ksqlDB supported for existing applications.

Choose ksqlDB when everything is already a Kafka topic, the logic is simple, you are committed to Confluent, and you have read Confluent's roadmap.

Comparison table

DimensionRisingWaveMaterializeFelderaTimeplus Proton
LicenseApache 2.0Business Source License 1.1; license key required for self-managedMIT (open source edition)Apache 2.0 (Proton)
Core modelIncremental materialized viewsIncremental materialized viewsIncremental views on DBSPStreaming SQL on a ClickHouse-derived engine
Protocol and dialectPostgreSQLPostgreSQLCalcite SQL over HTTPClickHouse SQL
ConsistencyExactly-once, snapshot-consistent reads across viewsStrict serializability across viewsSee Feldera docsSee Timeplus docs
Native database CDCPostgreSQL, MySQL, SQL Server, MongoDBPostgreSQL, MySQL, SQL ServerVia Debezium and KafkaVia Kafka or Enterprise connectors
Other sourcesKafka, Pulsar, Kinesis, S3, Pub/Sub, MQTT, NATS, webhooks, IcebergKafka, Redpanda, webhooksKafka, HTTP, IcebergKafka, Pulsar and others; see docs
IcebergSink, source, hosted REST catalog, compactionSinkSink and source connectorsVia Enterprise connectors
Vector type and indexYes (index in technical preview)Not documentedNoNo
Official MCP serverYesNot documentedNoNo
State placementObject storage with stateless computeMemory on compute clusters, persisted to object storageDisk spillLocal MergeTree storage
Managed offeringRisingWave Cloud, BYOCMaterialize CloudFeldera CloudTimeplus Cloud

Side by side in SQL: Materialize and RisingWave

The two PostgreSQL-compatible systems are close enough that a side-by-side is useful. Differences are concentrated in source DDL and time semantics.

Defining a streaming source

Materialize:

-- Materialize: Kafka source
CREATE SOURCE orders_source
FROM KAFKA CONNECTION kafka_conn (TOPIC 'orders')
FORMAT JSON
INCLUDE TIMESTAMP AS event_time;

-- Materialize: PostgreSQL CDC source
CREATE SOURCE pg_source
FROM POSTGRES CONNECTION pg_conn (PUBLICATION 'mz_publication')
FOR TABLES (public.orders, public.customers);

RisingWave:

-- RisingWave: Kafka source
CREATE SOURCE orders_source (
    order_id    BIGINT,
    customer_id BIGINT,
    total       NUMERIC,
    event_time  TIMESTAMPTZ
) WITH (
    connector = 'kafka',
    topic = 'orders',
    properties.bootstrap.server = 'kafka:9092',
    scan.startup.mode = 'latest'
) FORMAT PLAIN ENCODE JSON;

-- RisingWave: PostgreSQL CDC source, no Debezium
CREATE SOURCE pg_cdc_source WITH (
    connector = 'postgres-cdc',
    hostname = 'prod-db.internal',
    port = '5432',
    username = 'cdc_user',
    password = 'secret',
    database.name = 'ecommerce',
    schema.name = 'public'
);

CREATE TABLE orders (
    id          BIGINT PRIMARY KEY,
    customer_id BIGINT,
    total       NUMERIC,
    status      VARCHAR,
    updated_at  TIMESTAMPTZ
) FROM pg_cdc_source TABLE 'public.orders';

The concepts are identical: define a source, specify the format, map tables. The keywords differ, so source DDL is rewritten during a migration while the mental model carries over. The RisingWave form follows its PostgreSQL CDC documentation.

Defining a materialized view

For aggregations and joins the SQL is often identical.

Materialize:

CREATE MATERIALIZED VIEW revenue_by_status AS
SELECT
    status,
    COUNT(*)   AS order_count,
    SUM(total) AS total_revenue
FROM orders
GROUP BY status;

RisingWave:

CREATE MATERIALIZED VIEW revenue_by_status AS
SELECT
    status,
    COUNT(*)   AS order_count,
    SUM(total) AS total_revenue
FROM orders
GROUP BY status;

Both support GROUP BY, joins, window functions and subqueries with PostgreSQL semantics. Differences surface in time handling: Materialize's temporal filters and mz_now() are tied to its timestamp-based consistency model, while RisingWave uses watermarks and time-window table functions.

Time-based aggregations

Materialize:

CREATE MATERIALIZED VIEW orders_per_minute AS
SELECT
    date_trunc('minute', event_time) AS window_start,
    COUNT(*)   AS order_count,
    SUM(total) AS revenue
FROM orders
GROUP BY date_trunc('minute', event_time);

RisingWave:

CREATE MATERIALIZED VIEW orders_per_minute AS
SELECT
    window_start,
    COUNT(*)   AS order_count,
    SUM(total) AS revenue
FROM TUMBLE(orders, event_time, INTERVAL '1' MINUTE)
GROUP BY window_start;

RisingWave's TUMBLE table function makes the window explicit and exposes window_start and window_end. Add a watermark to the source and EMIT ON WINDOW CLOSE to the view if you want each window emitted once rather than updated as late rows arrive. Materialize's date_trunc form also works in RisingWave if you prefer it.

Vector search in RisingWave

This has no Materialize equivalent as of November 2026. The syntax follows the AI functions and vector index documentation. Vector indexes are in technical preview and require append-only inputs.

-- Compute embeddings as products arrive from the stream
CREATE MATERIALIZED VIEW product_embeddings AS
SELECT
    product_id,
    product_name,
    category,
    openai_embedding(
        '{"model": "text-embedding-3-small", "api_key": "sk-..."}'::jsonb,
        product_name || ' ' || category || ' ' || description
    )::vector(1536) AS embedding
FROM products;

-- Approximate nearest neighbour index
CREATE INDEX product_embeddings_idx
ON product_embeddings USING hnsw (embedding)
INCLUDE (product_name, category)
WITH (distance_type = 'inner_product');

-- Find the ten most similar products to a query vector
SELECT product_name, category
FROM product_embeddings
ORDER BY embedding <-> $1::vector(1536)
LIMIT 10;

Embeddings are computed as products arrive, indexed, and queried over the same PostgreSQL connection used for everything else. Whether this belongs in your streaming database or in a dedicated vector store is a design choice; the point is that it is available here and not in Materialize.

Migrating from Materialize to RisingWave

The migration is manageable because both systems share the programming model. Here is what moves and what does not.

Transfers directly. View logic (GROUP BY, joins, window functions, subqueries). PostgreSQL client connections and drivers. BI integrations (Metabase, Grafana, Superset). dbt models through the PostgreSQL adapter.

Needs rewriting. Source DDL, as shown above. Sink DDL for Kafka or Iceberg destinations. Temporal filters built on mz_now(), which become watermarks and time windows. Anything relying on strict serializability across interactive transactions, which needs a correctness review rather than a syntax change.

Steps.

  1. Inventory sources, views and sinks in Materialize, and mark any view whose correctness depends on strict serializability.
  2. Run RisingWave alongside Materialize in staging; both speak PostgreSQL protocol on different hosts.
  3. Recreate sources in RisingWave syntax and confirm events arrive.
  4. Recreate views one at a time and compare output on the same input for at least one business cycle, paying attention to late data and window boundaries.
  5. Repoint applications and BI tools; this is usually a connection string change.
  6. Decommission Materialize after validation.

Validating output equivalence takes longer than writing the SQL.

When to stay on Materialize

Your correctness argument depends on strict serializability. If you have validated your application against Materialize's consistency model and it matters, switching means re-validating under a different model. That is a real cost and sometimes a blocker.

Your sources are PostgreSQL, MySQL, SQL Server or Kafka and your sinks are Kafka or Iceberg. Within that envelope Materialize's coverage is complete and the source-breadth argument for switching does not apply.

You rely on Materialize Cloud and the license is acceptable. A mature managed service with a license your legal team has already approved is a legitimate reason to stay.

Your existing investment is large and nothing is broken. Migration cost is real. Switching for its own sake is not a good reason.

When RisingWave is the wrong choice

  • Strict serializability across interactive transactions is a hard requirement. Stay on Materialize.
  • You need complex event processing. MATCH_RECOGNIZE and CEP are Flink's; neither Materialize nor RisingWave offers them.
  • Your team thinks in ClickHouse SQL and wants one engine for streaming and historical queries. Look at Timeplus Proton.
  • Everything is a Kafka topic and you are committed to Confluent. ksqlDB or Confluent's Flink may fit better than adding a database.
  • You need ad hoc analytics over years of history. Use a real-time OLAP engine, possibly fed by RisingWave.

What is published on performance

No independent benchmark compares Materialize, RisingWave, Feldera and Timeplus like for like as of November 2026. RisingWave Labs publishes a Nexmark benchmark against Apache Flink with hardware, configuration and queries documented; it is vendor-run and does not include Materialize. Materialize and Feldera publish their own vendor-run results. Run your own top queries on two candidates before deciding.

FAQ

What are the Materialize alternatives in 2026?

RisingWave (Apache 2.0, PostgreSQL compatible, native CDC for four databases, Iceberg catalog management, vector support, MCP server), Feldera (MIT, DBSP-based, Kafka and HTTP sources), Timeplus Proton (Apache 2.0, ClickHouse-style SQL), Apache Flink SQL with a serving store, and ksqlDB for Kafka-only stacks. RisingWave is the closest in programming model because both are PostgreSQL-compatible streaming databases built on incrementally maintained views.

Is Materialize open source?

No. Materialize uses the Business Source License 1.1, which is source-available. Each release converts to an open license four years after publication. Self-managed deployments, including the free Community edition, require a license key. RisingWave, Timeplus Proton and Flink are Apache 2.0; Feldera's open source edition is MIT.

How does RisingWave differ from Materialize?

Both maintain materialized views incrementally and serve them over PostgreSQL protocol. Materialize offers strict serializability across views, keeps state in memory, and is licensed under the Business Source License. RisingWave offers exactly-once processing with snapshot-consistent reads, keeps state on object storage with stateless compute, adds MongoDB CDC and more non-Kafka sources, manages Iceberg catalogs and compaction, has vector and MCP support, and is Apache 2.0.

Can I migrate from Materialize to RisingWave?

Yes. View logic, client connections, BI integrations and dbt models carry over. Source and sink DDL is rewritten, temporal filters using mz_now() are re-expressed with watermarks and time windows, and any view that depends on strict serializability needs a correctness review.

Does Materialize support Iceberg?

Yes, as a sink with upsert and append modes, per its documentation. RisingWave additionally reads Iceberg as a source, hosts a REST catalog and runs compaction; Feldera has Iceberg connectors.

Where to go next

For the full field, pricing models and methodology, see the streaming database comparison hub. If you are also weighing Flink, read Apache Flink alternatives for SQL teams. If you find a factual error in this article, open an issue and we will correct it.

The engine for real-time streaming data.
Analyze, search, and decide.
GitHubXLinkedInSlackYouTube
Sign up for our to stay updated.