Quix

Editor’s note: This Quix review is based on my hands-on test of Quix Streams 3.28.1 and Quix Cloud in October 2026. I weighed pricing, stateful processing, deployment, storage, and alternatives including Confluent Cloud for Apache Flink, RisingWave, Pathway and Bytewax.

Quick verdict: I recommend Quix Streams for Python teams already running Kafka that need windows, joins, and exactly-once processing without the JVM. The library is free; Quix Cloud is sales-led, last listed from GBP 4,200/month, and now targets engineering test data.

Quix’s pandas-like StreamingDataFrame handles Kafka processing in Python rather than Apache Flink’s JVM-based runtime.

In this Quix review, I’ll take a closer look at pricing, Quix Streams windows and joins, Quix Cloud deployment, hosting, the engineering pivot and alternatives.

Key Takeaways

• Free Apache 2.0 library: Requires Python 3.11+. Version 3.28.1 arrived October 15, 2026; releases arrive roughly every two to six weeks.
• No live Cloud price list: Last published: Professional from GBP 4,200/month, Scale from GBP 14,200/month, Critical custom. AWS Marketplace lists $3,363.84/month for two nodes.
• Kafka is mandatory: Choose Quix-managed Kafka or your own broker through Confluent Cloud, Redpanda, Aiven, or self-hosting.
• Stateful processing: Event-time and count windows, as-of and lookup joins, and RocksDB recovery are included. Exactly-once is opt-in.
• Engineering-first direction: Since mid-2026, hardware test data and Quix AI have replaced general streaming as Quix’s headline pitch.

Pros and Cons

Quix Pricing: How Much Does It Cost?

Quix Streams is free under Apache 2.0; Quix Cloud requires a sales conversation. Quix’s last published price list (May 2026) started Professional at GBP 4,200/month. There is no live public price list, and getting a Cloud account starts with booking a session.

• Quix Streams (free): for Python developers running their own Kafka applications without buying Quix Cloud. Hosting and broker costs remain yours.
• Free trial (30 days): for evaluating Professional with the same resource quotas, community Slack support, and no SLA. The last published offer required no credit card.
• Professional (from GBP 4,200/month): for teams needing public-cloud BYOC and user and project management, with permissions, personal access tokens, and private templates.
• Scale (from GBP 14,200/month): for private-cloud or on-premise deployment, with multi-cluster management, SSO, and advanced monitoring.
• Critical (custom): for air-gapped installations requiring custom networking and security controls, plus a user activity log.

AWS Marketplace lists “Quix Cloud – Enterprise” at $3,363.84/month for a one-month, two-node contract with Basic support. AWS infrastructure costs may be extra, and no trial is listed.

Plan	Price	What it adds
Quix Streams	Free, Apache 2.0	Python library; self-run with Kafka 0.10+
Free trial	Free for 30 days, no card, last published	Professional quotas; community Slack; no SLA
Professional	From GBP 4,200/month, last published	Public-cloud BYOC; user and project management; permissions; personal access tokens; private templates
Scale	From GBP 14,200/month, last published	Private-cloud and on-premise BYOC; multi-cluster; SSO; advanced monitoring
Critical	Custom	Air-gapped hosting; custom networking and security controls; user activity log
AWS Marketplace Enterprise	$3,363.84/month, two-node, one-month contract	Basic support; connects to existing Kafka or Kinesis

Quix’s retired mid-2025 plans were Developer at $199/month and Business at $349/month plus $401.50 per node; those prices no longer apply.

The Marketplace contract connects to existing Kafka or Kinesis. Professional’s last-listed package instead emphasizes public-cloud BYOC and project management; I recommend choosing by deployment requirements rather than treating Enterprise as a cheaper Professional tier.

Is Quix Good Value for Money?

• Hourly alternatives: Confluent Cloud for Apache Flink starts at $0.21 per CFU-hour; RisingWave Basic starts at $0.227 per RWU-hour with a seven-day trial. I prefer these for SQL-first workloads.
• Platform value needs operational work: I recommend the paid platform when Git-synced deployment and BYOC replace infrastructure management across your Python services.
• The library covers processing: Windows, joins, and state do not require Cloud. Start with Streams if you already operate containers and Kafka.
• Infrastructure remains a separate expense: Confluent bills Kafka and networking separately; Quix’s Marketplace contract can also carry AWS infrastructure charges.

Reviewer’s Notes: I recommend starting with Quix Streams on your own Kafka. Choose the Professional trial for Git-synced deployments, public-cloud BYOC, and monitoring across environments; choose Scale for SSO or on-premise hosting. The GBP figures describe May 2026’s last published plans, not a live offer.

My Experience With Quix

I started with Quix Streams locally, without a Cloud subscription, then moved to Quix Cloud’s Git-linked deployment flow. Quix created the time-limited Cloud account after a booked session; there was no self-serve registration form in that onboarding path.

Building a Pipeline Locally With Quix Streams

I installed Quix Streams with pip install quixstreams using Python 3.11+. The Application connected to a Kafka broker rather than provisioning one. Conda-forge is the alternative installation route.

1. Configured the Application: I supplied the Kafka connection details and selected the application’s processing guarantee.
2. Defined the topics: I identified the input and output topics and configured their serialization.
3. Built a StreamingDataFrame: I filtered records, applied Python transformations, and grouped records by the key needed for aggregation.
4. Added stateful processing: I added a tumbling-window aggregation and an as-of join to the pipeline.
5. Ran the Application: I started the application against Kafka with the processing pipeline defined.

I preferred this Python-native workflow to PyFlink for transformations already written in Python. Quix did not require a separate JVM processing runtime, although Kafka remained an infrastructure dependency.

The default guarantee was at-least-once. I explicitly configured processing_guarantee for exactly-once processing through Kafka transactions rather than leaving the default in place.

Moving the Pipeline Into Quix Cloud

I completed the Quix CLI quickstart and pushed the pipeline to Git. In Quix Cloud, I connected that repository to a project rather than recreating the pipeline through browser settings.

1. Created a project: I authorized the QuixIntegration GitHub app and selected the repository.
2. Created the environment: I named it PRODUCTION and associated it with the main branch.
3. Selected Kafka hosting: I chose the Quix-managed broker for the environment.
4. Synchronized the pipeline: I clicked Sync environment, reviewed the Sync to this commit diff, and confirmed.

Git integration also supports Bitbucket and Azure DevOps. For an existing Kafka deployment, broker choices include:

• Confluent Cloud
• Redpanda
• Aiven
• Self-hosted Kafka

Quix stored pipeline configuration as YAML alongside the code. I favored that arrangement because deployment changes could follow the same review process as application changes.

I also opened the online code editor. For deployment, I used the repository and commit diff as the reference rather than treating browser edits as a separate configuration source.

Deploying and Monitoring

In New Deployment, I configured the application as a continuously running service:

1. Application and version: I selected the application and its version; Quix also supports pinning a tag or commit.
2. Environment variables: I bound configuration to project variables or secrets.
3. Execution type: I selected a service rather than a job, which runs once.
4. Resources: I set CPU and memory limits and the replica count.

Resource requests have a floor of 10 millicores and 50 MB per replica. Trial organizations use a 10% reservation, while project quotas can cap CPU and memory.

I opened the service panel to inspect resource metrics and connected topics. I also reviewed:

• Real-time logs and consumer lag
• Live data in waveform and table views
• CPU and memory metrics

Reviewer’s Notes: I preferred Quix’s Git-linked environments and commit-based synchronization to browser-only configuration. The sales-led account setup remained a drawback for a small experiment; RisingWave offers a seven-day trial, while Confluent’s Basic Kafka cluster starts at $0/month.

Quix Streams: Windows, Joins and State

Quix Streams 3.28.1, released October 15, 2026, provides a pandas-like StreamingDataFrame over Kafka under Apache 2.0. Six releases between June and October show active delivery, compared with Bytewax’s last PyPI release on November 25, 2024.

Windowing

Quix’s time-based windows use event time, drawn from Kafka message timestamps or a custom extractor and tracked per key. Skip Quix’s tumbling windows when your application requires output triggered by wall-clock time.

Window category	Supported behavior
Tumbling	Non-overlapping time windows
Hopping	Time windows with a configured hop
Sliding	Sliding time windows
Session	Windows grouped around activity sessions
Count	Tumbling and sliding windows based on record counts

Supported aggregators include:

• Count, Sum, and Mean
• Min and Max
• First and Last
• Earliest and Latest
• Collect

A time-based tumbling window needs new messages to close. Open GitHub issue 790 requests wall-clock triggering. A quiet key can therefore leave a window open, making this a poor fit for sparse sensor alerts that must fire on a schedule.

Joins

join_asof, available since version 3.15.0, matches each left record with the latest right record sharing its key at or before its timestamp. A grace period accommodates late arrivals.

For a two-topic join, partition counts and key partitioning must match. Quix forces the range assignment strategy so corresponding partitions reach the same consumer. Joins are stateful, with right-side records retained in a state store.

The lookup() join enriches records from external systems. I recommend an as-of join for timestamp-aligned telemetry and a lookup for external reference data.

State and Delivery Guarantees

Quix stores state in RocksDB per partition, backed by Kafka changelog topics for recovery. Open GitHub issues 1101 and 1014 request external or pluggable stores; open GitHub issue 988 requests interactive state queries like Kafka Streams offers.

Exactly-once processing is opt-in through Kafka transactions, not the default. Serialization options include:

• JSON
• Avro with Schema Registry integration
• Protobuf with Schema Registry integration

I recommend Quix for Kafka-in, Kafka-out services with keyed state. Skip it when interchangeable state backends or interactive state queries are core requirements.

Connectors, Quix Lake and Hosting Options

Quix Streams includes prebuilt database and messaging connectors, but its Sources and Sinks APIs are beta. Sources run in subprocesses and write into intermediate Kafka topics, so connecting Kinesis does not remove the Kafka dependency.

Supported sink destinations include:

• Analytics and tables: Apache Iceberg, BigQuery, and PostgreSQL.
• Search and operational storage: Elasticsearch, MongoDB, and Redis.
• Time-series databases: InfluxDB 1 and 3, plus TDengine.
• Messaging and object storage: MQTT, Kinesis, Google Pub/Sub, and Amazon S3.

Open GitHub issue 921 requests Kafka-free operation. Skip Quix for Kafka-free processing, even when your original data arrives through Pub/Sub or Kinesis.

Quix Lake

Quix Lake captures Kafka topic data into storage you control. Destinations include:

• Amazon S3
• Azure Blob Storage
• Google Cloud Storage
• MinIO
• Local folders

Its Data Lake sink stores raw Kafka messages as Avro segments with a Parquet index and supports Replay. I recommend it when historical input needs to run through a revised pipeline.

The Lakehouse sink writes Parquet tables with a catalog for SQL queries. Running both sinks against one topic roughly doubles its storage. Choose both when replay and SQL access justify keeping separate representations of the same topic.

Hosting and Security

Quix’s hybrid hosting pairs a Quix-managed control plane with deployment clusters you control.

• Fully managed: From multi-tenant serverless hosting to single-tenant deployment in your cloud account.
• BYOC: Blackbox deployment or Guided Self-Hosted.
• Hybrid: A Quix-managed control plane with deployment clusters you control, including multi-cluster management.

The last published plan split placed public-cloud BYOC in Professional, private-cloud and on-premise hosting in Scale, and air-gapped hosting in Critical. Professional is not the entry point for an on-premise installation.

Quix announced SOC 2 Type II on September 30, 2026, in addition to its existing ISO 27001 accreditation. The report is available on request.

Confluent Cloud for Apache Flink runs within Confluent’s managed cloud service. I favor Quix when on-premise or air-gapped deployment is a purchasing requirement.

Quix AI and the Shift to Engineering Test Data

Quix’s June 22, 2026 hardware-testing announcement introduced an engineering-focused AI direction. Its current product combines the Quix Data Platform with Quix AI rather than leading with general-purpose Python stream processing.

• Requirements Manager: Works over Jama, DOORS, Polarion, and Teamcenter to support requirements workflows.
• Quix Lab: Handles verification and test scheduling, with design-of-experiments analysis and reporting.
• Test Manager: Compares virtual and physical test results by signal and configuration.

The underlying Data Platform provides:

• Pipelines for real-time data processing
• Lakehouse for full-resolution recordings on your own storage in open formats
• Apps

Deployment options span:

• Cloud
• On-premise
• Hybrid
• Multi-cloud

Quix targets engineering organizations in:

• Automotive and aerospace
• Defense
• Energy and manufacturing

The homepage features Audi, and Quix’s own Viessmann case study claims 90% less product testing time. I recommend evaluating Quix AI for engineering-test workflows, not choosing the streaming library on the strength of that customer result.

Quix was founded in 2020 in London by the team behind McLaren Racing’s data platform. I see a clearer commercial fit for hardware-test teams than for a company buying only generic event transformations.

The homepage and product page no longer headline Quix Cloud or Quix Streams. The library continues shipping, but engineering testing drives the commercial pitch. For a SQL-first analytics buyer, I prefer RisingWave’s streaming SQL database, with Basic cloud from $0.227 per RWU-hour; for Python applications already using Kafka, Quix Streams remains my stronger starting point.

How Does Quix Compare to Competitors?

I favor Quix for Python-native Kafka processing with BYOC or on-premise deployment, not as the default choice for every streaming workload.

• Confluent Cloud for Apache Flink: Starts at $0.21 per CFU-hour, with rates varying by region. It supports Flink SQL, Java, and Python APIs. Basic Kafka starts at $0/month and Standard at about $385/month; Kafka and networking are billed separately. I prefer it for SQL-first teams already using Confluent.
• RisingWave: Basic Cloud starts at $0.227 per RWU-hour with a seven-day trial. The self-managed edition is Apache 2.0; Pro and self-managed commercial offerings go through sales. I prefer RisingWave for streaming SQL rather than Python application services.
• Pathway: Its free Community tier allows four cores and 8 GB RAM under BSL 1.1, which is not an OSI open-source license. Version 0.33.0 arrived September 18, 2026. Choose it for reactive Python pipelines when its Community limits and license fit your project.
• Bytewax: An Apache 2.0 Python framework with a Rust engine. Its last PyPI release was 0.21.1 on November 25, 2024. I recommend it mainly for existing Bytewax applications; Quix’s more recent releases make it my starting point for a new Kafka project.
• Faust (faust-streaming): The community-maintained fork of Robinhood’s Faust released version 0.15.4 on October 28, 2026. Consider it when you want the Faust library rather than Quix Cloud’s managed deployment layer.
• Decodable: Redis announced its intent to acquire Decodable on September 4, 2025. It is now folded into Redis Cloud and Redis Data Integration, rather than sold as a standalone alternative. Evaluate it as a Redis feature.

Tool	Language	Pricing entry	Self-host	Best for
Quix	Python	Streams free; Cloud last listed from GBP 4,200/month	Streams self-run; Cloud BYOC, hybrid, on-premise	Stateful Python Kafka services
Confluent Cloud for Apache Flink	SQL; Java/Python APIs	From $0.21/CFU-hour	Managed cloud only	Managed Flink on Confluent
RisingWave	SQL	From $0.227/RWU-hour; Apache 2.0 self-managed edition	Self-managed edition, Apache 2.0	Streaming SQL
Pathway	Python	Free Community, four cores/8 GB	Community self-hosted only	Reactive Python pipelines
Bytewax	Python; Rust engine	Free, Apache 2.0	Self-run framework	Existing Bytewax applications
Faust-streaming	Python	Community library	Self-run library	Projects using the Faust fork

For SQL-first processing, my shortlist is RisingWave or Confluent Cloud for Apache Flink. For Python services with Kafka already in place, I recommend Quix Streams before a paid platform subscription.

Pathway’s four-core and 8 GB Community limits make its free tier a different proposition from Quix Streams’ Apache 2.0 library. I prefer Quix when that licensing distinction matters.

How I Reviewed Quix

I built a Kafka pipeline with Quix Streams 3.28.1, using StreamingDataFrame transformations, a tumbling window, and an as-of join. I installed the library with pip and configured its processing guarantee.

For Quix Cloud, I authorized the QuixIntegration GitHub app, created PRODUCTION on main, and synchronized the environment. I configured a service’s CPU, memory, and replicas, then inspected logs and metrics.

• Pricing and plan gating: I compared Professional, Scale, and Critical.
• Library features and limits: I evaluated windows, joins, and state.
• Deployment and hosting: I assessed Git synchronization and infrastructure control.
• Connectors and storage: I examined Kafka dependencies and Replay.
• Company direction: I weighed engineering testing against general streaming.

I compared Confluent Cloud for Apache Flink, RisingWave, Pathway, Bytewax, Faust, and Decodable.

Prices current as of October 2026.

Should You Use Quix for Python Stream Processing?

I recommend Quix Streams for Python teams already running Kafka: its active release cadence, stateful operations, and Apache 2.0 license make it a strong library choice. Quix Cloud adds Git-synced deployment and infrastructure management, but its last-listed GBP 4,200/month entry price puts it beyond a casual managed-hosting purchase.

Use the library if your application needs keyed windows and joins without introducing a JVM processing runtime. Its tumbling windows depend on new messages arriving, and processing state stays in RocksDB. Skip Quix when wall-clock window closure or interchangeable state stores are essential.

I recommend the platform when BYOC and centralized deployment management replace infrastructure work across your Python services. Choose Scale for on-premise hosting or SSO; choose Critical for air-gapped installations.

Automotive and aerospace test teams fit Quix’s current commercial direction. For general-purpose Kafka applications, I prefer starting with the free library rather than buying into the engineering platform.

For SQL-first streaming, choose RisingWave or Confluent Cloud for Apache Flink instead of paying for a Python deployment platform.

Start with pip install quixstreams and run a windowed aggregation against your own Kafka topic before booking a Quix Cloud session.

FAQ

Is Quix Streams free?

Yes, Quix Streams is free under Apache 2.0, without requiring a Quix Cloud subscription. Version 3.28.1 requires Python 3.11+ and a Kafka broker, with Kafka 0.10+ as the baseline requirement. Install it using pip install quixstreams or conda-forge. You still pay for the infrastructure running your application and broker; the free license does not include managed hosting.

How much does Quix Cloud cost?

Quix Cloud has no live public price list. Its last published list, from May 2026, started Professional at GBP 4,200/month and Scale at GBP 14,200/month, with Critical priced individually. AWS Marketplace lists a separate $3,363.84/month two-node contract. The last published Professional trial lasted 30 days without a card; Quix creates a time-limited account after you book a session.

Does Quix work without Kafka?

No, Quix Streams requires Kafka, including when data originates in Kinesis, S3, or Google Pub/Sub. Those sources write to intermediate Kafka topics before processing. You can use Quix-managed Kafka or connect your own broker through Confluent Cloud, Redpanda, Aiven, or a self-hosted deployment. Skip Quix if removing Kafka is a core requirement; its source connectors do not remove that dependency.

Is Quix better than Apache Flink?

Quix is a better fit for Python teams building Kafka-in, Kafka-out services that need keyed state without a JVM processing runtime. I favor Flink for SQL-first applications; Confluent supports Flink SQL alongside Java and Python APIs. Confluent Cloud for Apache Flink starts at $0.21 per CFU-hour, with region-dependent rates and separate Kafka and networking costs. See How Does Quix Compare to Competitors? above.