Develop real-time data apps and services faster

All you need is Python, we'll manage the rest.

alt
99.872%

Uptime (90 days)

57tb

Processed

1390

Developers

934

Organizations

alt
Loading Image

By developers for developers

A serverless real-time data platform

No need to be a DevOps guru. Choose a template, click and deploy.

Building real-time apps and services requires lots of components running in concert: Kafka, VPC hosting, infrastructure as code, container orchestration, observability, CI/CD, persistent volumes, databases, and much more.

The Quix platform takes care of all the moving parts. You just connect your data and start building. That’s it. No provisioning clusters or configuring resources.

alt

Features

What can you build with Quix?

Any kind of real-time back-end application or data processing pipeline: from end-to-fraud detection pipelines to event-driven service architectures.

SELECT INDUSTRY
frame
Finance ingest
app.py
app.cs
Graphic Background
topic = quix.open_output_topic("payment-transactions")
stream = topic.get_or_create_stream(CUSTOMER_ID)
stream.events.write(payments)
//sends parameter (payment) data

using var outputTopic = quix.OpenOutputTopic("payment-transactions");
var streamWriter = outputTopic.CreateStream("CUSTOMERID");

streamWriter.Events
    .AddTimestamp(DateTime.Now)
    .AddValue("Payment", PaymentData)
    .Write();

Stream events from your external sources

Use Quix connectors to ingest transaction messages streamed from your finanical processing systems in a virtual private cloud or on-premise datacenter.

All data in transit is encrypted end-to-end and compressed with G-Zip and Protobuf for security and efficiency.

frame
Finance enrich
app.py
app.cs
Graphic Background
transactions = quix.open_input_topic("payment-transactions")
blocked_topic = quix.open_output_topic("payment-blocked")
blocked_payments = blocked_topic.create_stream("blocked_payments")
blocked_cache = quix.open_input_topic("blocked_accounts").as_cache()

// Lets get this into Pandas (changed to blocking theme)

def handle_data(data):
 if data.account_num in blocked_cache:
  blocked_payments.events.add("Block", data.transaction_num)

transactions.on_read_data += handle_data
//receives parameter data sends parameter data

using var inputTopic = quix.OpenInputTopic("payment-transactions");
using var blockedAccounts = quix.OpenInputTopic("blocked-accounts").AsCache();
using var outputTopic = quix.OpenOutputTopic("payment-blocked");

inputTopic.OnStreamReceived += (s, streamReader) =>
{
    var streamWriter = outputTopic.CreateStream();
    streamReader.Parameters.OnRead += (paymentData) =>
    {
        if (blockedAccounts.Contains(paymentData.AccountNumber))
        {
            streamWriter.Parameters
                .Buffer
                .AddTimestamp(DateTime.Now)
                .AddValue("Block", paymentData.TransactionNumber)
                .Write();
        }
    };
};

Clean and enrich your events

Run, test and deploy enrichment functions in the Quix serverless platform to:

  • Process and aggregate transaction data.
  • Query external services for supplementary data such as blocked account numbers.
frame
Finance execute
app.py
app.cs
Graphic Background
transactions = quix.open_input_topic("payment-transactions")
fraud_topic = quix.open_output_topic("fraud-transactions")
fraud_model = pickle.load(open("fraud_model.pkl"))

def handle_data(data, fraud_stream):
 is_fraud = model.detect(data)
 fraud_stream.events.write(data.transaction)

transactions.on_read_data += handle_data
//receives parameter data sends fraud event

using var inputTopic = quix.OpenInputTopic("payment-transactions");
using var outputTopic = quix.OpenOutputTopic("fraud-transactions");
var fraudModel = System.IO.File.OpenRead("fraudModel.pkl");

inputTopic.OnStreamReceived += (s, streamReader) =>
{
    var streamWriter = outputTopic.CreateStream();
    streamReader.Parameters.OnRead += (paymentData) =>
    {
        if (fraudModel.Detect(paymentData))
        {
            streamWriter.Events
                .AddTimestamp(DateTime.Now)
                .AddValue("PaymentData", paymentData)
                .Write();
        }
    };
};

Apply business logic

Run, test and deploy business logic functions in the Quix serverless platform to:

  • Detect fraudelent patterns with machine learning models or rule-based algorithms.
  • Stream the results for business logic execution.
  • Create fraud warning messages as troubleshooting tickets or display them in support dashboards.
frame
Finance persist
app.py
app.cs
Graphic Background
fraud_transactions = quix.open_input_topic("fraud-transactions")
segment = segment_connector("zen-desk")
big_query.connect()

def handle_data(data):
 segment.create_ticket(data, priority="HIGH")
 big_query.write(data)

fraud_transactions.on_read_data += handle_data
//receives event data sends to segment and data lake

using var inputTopic = quix.OpenInputTopic("fraud-transactions");
var segmentConnector = new SegmentConnector("ZenDesk");
var dataLake = new BigQueryConnector();

inputTopic.OnStreamReceived += (s, streamReader) =>
{
 streamReader.Events.OnRead += (fraudData) =>
    {
        if (fraudData.FraudResult)
            segmentConnector.CreateTicket(fraudData, priority = "HIGH");
        dataLake.Write(fraudData);
    };
};

Trigger downstream services based on meaningful events

Create downstream functions that:

  • Write processed fraud statistics to a data lake, warehouse or database using our open-source connectors.
  • Trigger follow-up batch processing on persisted data.
frame
Manufacturing ingest
app.py
app.cs
Graphic Background
topic = quix.open_output_topic("factory")
stream = topic.create_stream(DEVICE_ID)
device = connector.get_device(DEVICE_ID)

while(device.is_running)
 data = device.get_data()
 stream.parameters.write(data)
using var outputTopic = quix.OpenOutputTopic("factory");
var streamWriter = outputTopic.CreateStream();
var device = deviceConnector.GetDevice("DEVICEID");

while (device.IsRunning)
{
    streamWriter.Parameters
        .Buffer
        .AddTimestamp(DateTime.Now)
        .AddValue("Temperature", device.Temperature)
        .AddValue("PowerOutput", device.PowerOutput)
        .AddValue("BatteryLevel", device.BatteryLevel)
        .Write();
}

Stream data from your external sources

Integrate the Quix SDK and configure your production firmware to connect to the Quix WebSocket API.

Stream high-volume telemetry data from your machinery to Quix.

All data in transit is encrypted end-to-end and compressed with G-Zip and Protobuf for security and efficiency.

frame
Manufacturing enrich
app.py
app.cs
Graphic Background
// Based on machine.type look up the service interval and set machine.hours_to_service it based on machine.hours_since_service.
// Also set machine.service_type

factory = quix.open_input_topic("factory")
service_topic = quix.open_output_topic("servicing")

def handle_data(device, service_stream):
 hours_till_service = device.service_interval - device.runtime
 if hours_till_service < 100:
  service_stream.events \
   .add("DeviceId", device.id) \
   .add("ServiceParts", device.service.parts) \
   .add("ServiceType", device.service.type) \
   .add("TimeRemaining", hours_till_service) \
   .write()

factory.on_read_data += handle_data
//receives param, identifies event and sends event, tags deviceid

using var inputTopic = quix.OpenInputTopic("factory");
using var outputTopic = quix.OpenOutputTopic("servicing");

inputTopic.OnStreamReceived += (s, streamReader) =>
{
    var streamWriter = outputTopic.CreateStream();
    streamReader.Parameters.OnRead += (deviceData) =>
    {
        var hoursTillService = deviceData.ServiceInterval - deviceData.RunTime;
        if (hoursTillService < 100)
        {
            streamWriter.Events
                .AddTimestamp(DateTime.Now)
                .AddTag("DeviceId", deviceData.Id)
                .AddValue("ServiceParts", deviceData.Service.Parts)
                .AddValue("ServiceType", deviceData.Service.Type)
                .AddValue("TimeRemaining", hoursTillService)
                .Write();
        }
    };
};

Clean and enrich your data

Run, test and deploy enrichment functions in the Quix serverless platform to:

  • Process and aggregate machine telemetry data.
  • Query external services for supplementary data such as historical degradation rates.
frame
Manufacturing execute
app.py
app.cs
Graphic Background
// If service is near, order service parts using POST.

factory = quix.open_input_topic("factory")
factory_events = quix.open_output_topic("factory-events")
parts_catalogue = parts_api.connect()

def handle_data(service, factory_events_stream):
 parts_required = service["ServiceParts"]
 parts_catalogue.order_parts(parts_required)
 factory_events_stream    .events \
  .add("PartsOrdered", parts_required) \
  .add("DeviceId", service["DeviceId"]) \
  .add("TimeRemaining", service["TimeRemaining"]) \
  .write()

factory.on_read_data += handle_data
//receives event, sends parameter and parts order to api, tags deviceid

using var inputTopic = quix.OpenInputTopic("servicing");
using var outputTopic = quix.OpenOutputTopic("factory-events");
var partsCatalogue = new PartsApi().Connect();

inputTopic.OnStreamReceived += (s, streamReader) =>
{
    var streamWriter = outputTopic.CreateStream();
    streamReader.Events.OnRead += (serviceData) =>
    {
        partsCatalogue.OrderParts(serviceData.ServiceParts);

        streamWriter.Parameters
            .Buffer
            .AddTimestamp(DateTime.Now)
            .AddTag("DeviceId", serviceData.DeviceId)
            .AddValue("PartsOrdered", serviceData.ServiceParts)
            .AddValue("TimeRemaining", serviceData.TImeRemaining)
            .Write();
    };
};

Apply business logic

Run, test and deploy business logic functions in the Quix serverless platform to:

  • Detect degradation patterns with machine learning models or rule-based algorithms.
  • Stream the results for business logic execution.
  • Create degradation warning messages that can be sent sent via text message to engineers or displayed in maintenance consoles.
frame
Manufacturing persist
app.py
app.cs
Graphic Background
factory_events = quix.open_input_topic("factory_events")
data_lake = snowflake.connect()

def handle_data(service):
 parts = service["PartsOrdered"]
 device_id = service["DeviceId"]
 time_remaining = service["TimeRemaining"]
 data_lake.persist(datetime.now(), parts, device_id, time_remaining)

factory_events.on_read_data += handle_data
//receives parameter, sends to snowflake

using var inputTopic = quix.OpenInputTopic("factory-events");
var snowflakeConnector = new SnowflakeConnector();

inputTopic.OnStreamReceived += (s, streamReader) =>
{
    streamReader.Parameters.OnRead += (serviceData) =>
    {
        snowflakeConnector.PersistData(DateTime.Now,
            serviceData.PartsOrdered,
            serviceData.DeviceId,
            serviceData.TimeRemaining);
    };
};

Trigger downstream services based on meaningful events

Create downstream serverless functions that:

  • Write processed degradation statistics to a data lake, warehouse or database using our open-source connectors.
  • Trigger follow-up batch processing on persisted data
frame
Mobility ingest
app.py
app.cs
Graphic Background
topic = quix.open_output_topic("vehicle-telemetry")

telemetry_payload = {timestamp: get_date(), location: coordinates}

stream = topic.create_stream(vehicle_id)
stream.parameters.write(telemetry_payload)
using var outputTopic = quix.OpenOutputTopic("vehicle-telemetry");
var telemetryPayload = $@"[{{ 'timestamp': '{DateTime.Now}',
 'location': coords }}]";
var streamWriter = outputTopic.CreateStream();

streamWriter.Parameters
    .Buffer
    .AddTimestamp(DateTime.Now)
    .AddTag("VehicleId", this.VehicleId)
    .AddValue("Telemetry", telemetryPayload)
    .Write();

Stream data from your external source

Configure your firmware or client apps to connect to the Quix WebSocket API and stream telemetry messages from your vehicles to Quix.

All data in transit is encrypted end-to-end and compressed with G-Zip and Protobuf for security and efficiency.

frame
Mobility enrich
app.py
app.cs
Graphic Background
telemetry = quix.open_input_topic("vehicle-telemetry")
output_topic  = quix.open_output_topic("telemetry-enriched")
weather_data = weather_api.connect()

def handle_data(df: pd.DataFrame):
 df['weather'] = df.apply(lambda row: weather_data[row.region], axis = 1)

 output_stream.events.write(telemetry)
//receives params sends params

using var inputTopic = quix.OpenInputTopic("vehicle-telemetry");
using var outputTopic = quix.OpenOutputTopic("telemetry-enriched");
var weatherData = httpApi.GetWeatherData();

inputTopic.OnStreamReceived += (s, streamReader) =>
{
 var streamWriter = outputTopic.CreateStream();
    streamReader.Parameters.OnRead += (vehicleData) =>
    {
        var region = vehicleData.Timestamps[0].Parameters["region"].StringValue;
        var regionWeather = weatherData[region];

        streamWriter.Parameters
            .Buffer
            .AddTimestamp(DateTime.Now)
            .AddTag("VehicleId", vehicleData.VehicleId)
            .AddValue("weather", regionWeather)
            .AddValue("vehicle", vehicleData)
            .Write();
    };
};

Clean and enrich your data

Run, test and deploy enrichment functions in the Quix serverless platform to:

  • Process and aggregate vehicle telemetry data.
  • Query external services for supplementary data such as the latest weather updates.
frame
Mobility execute
app.py
app.cs
Graphic Background
enriched_telemetry = quix.open_input_topic("telemetry-enriched")
hazards = quix.open_output_topic("hazards")
weather_model = pickle.load(open("hazard_model.pkl"))

def handle_data(data, hazard_warnings_stream):
 for vehicle in enriched_telemetry:
  vehicle_danger = weather_model.detect_danger(
   vehicle.weather_data,
   vehicle.gForce,
   vehicle.speed)

  hazard_warnings_stream.events.write(vehicle, vehicle_danger)

factory.on_read_data += handle_data
//receives param, sends danger event

using var inputTopic = quix.OpenInputTopic("telemetry-enriched");
using var outputTopic = quix.OpenOutputTopic("hazards");
var weatherModel = System.IO.File.OpenRead("weatherModel.pkl");

inputTopic.OnStreamReceived += (s, streamReader) =>
{
    var streamWriter = outputTopic.CreateStream();
    streamReader.Parameters.OnRead += (parameterData) =>
    {
        var weather = parameterData.Weather;
        var gForce = parameterData.Vehicle.GForce;
        var speed = parameterData.Vehicle.Speed;
        var vehicleDanger = weatherModel.DetectDanger(weather,
            gForce,
            speed);

        streamWriter.Events
            .AddTimestamp(DateTime.Now)
            .AddValue(parameterData.Vehicle.Id, vehicleDanger);
    };
};

Apply business logic

Run, test and deploy business logic functions in the Quix serverless platform to:

  • Detect hazardous patterns with machine learning models or rule-based algorithms.
  • Stream the results for business logic execution.
  • Create hazard warning messages that can be displayed in vehicle dashboards and device consoles.
frame
Mobility publish
app.py
app.cs
Graphic Background
hazard_warnings = quix.open_input_topic("hazards")
snowflake.connect()

def on_vehicle_hazard(hazard_data):
 if hazard_data.vehicle == this.vehicle:
  this.vehicle.display_hazard(hazard_data)

hazard_warnings.subscribe += on_vehicle_hazard
// receives an event

using var inputTopic = quix.OpenInputTopic("hazards");
using var snowflakeConnector = new SnowflakeConnector();

inputTopic.OnStreamReceived += (s, streamReader) =>
{
    streamReader.Events.OnRead += (eventData) =>
    {
        if (eventData.Id == this.Vehicle.Id)
        {
            this.Vehicle.DisplayHazard(eventData.VehicleDanger);
        }
    };
};

Trigger downstream services based on meaningful events

Create downstream serverless functions that:

  • Stream messages back to vehicle or device firmware through the Websocket API.
  • Write the processed hazard patterns to a data lake, warehouse or database using our open-source connectors.
+ add new alt
Deloitte

Discover more finance use cases

Use live data to auto-detect fraud. Unify customer data to increase total lifetime value with more personalized financial products.

Learn more
Finance thumbnail
Cloud NC logo mid

Optimizing manufacturing efficiency

How CloudNC use real-time data to make manufacturing 10X more efficient.

1

platform

3

developers

4

applications

Learn more
Cloud NC machines
Control logo mid

Optimizing connectivity for Control

How 1 developer built a real-time ML pipeline to improve cellular connectivity.

2

weeks

82

ML models

23%

performance boost

Learn more
Control Porsche Le Mans
alt

THE PRODUCT

What makes Quix so powerful?

alt
High performance serverless platform

1/3

A high-performance serverless platform

Quix services are designed to handle high volumes of real-time data. You get the simplicity of Lambda functions without the constraints. No cold starts. No payload limits. No deployment package limits. Functions can be stateless or stateful.

Minimal configuration and easy debugging

2/3

Minimal configuration and easy debugging

No more complicated YAML configurations, helm charts, or Docker files. Settings such as security, encryption, replication and partitioning all come preconfigured. No need to worry about data loss or lack of redundancy. Easy log inspection tools give you high observability into each part of your architecture.

Feature rich development tools

3/3

Feature-rich development tools

Open source connectors for most kinds of data sources. API's for when connectors aren't enough. Secrets and connection details managed through a simple UI. Define dependencies for all environments in one place. Build and test code online or in your favourite IDE, it's the same. Messages are automatically compressed and serialized to binary.

Chris Angell Cloud NC
“Quix has given us an environment to handle a huge amount of real-time machine data.”
— Chris Angell, Lead Systems Engineer, CloudNC
Nathan Sanders Control
“The lightbulb moment happened when we realized how resilient Quix is. We’ve automated a new product feature and Quix’s architecture gives us confidence it won’t fail.”
— Nathan Sanders, Technical Director, Control
Alex Chooi CK Delta
“We built a complex real-time pipeline for a zero-trust client on Quix, it's very secure and resilient.”
— Alex Chooi, Senior Software Engineer, CKDelta
Jonathan Wilkinson Airdale
“Quix saved us from hiring a whole data engineering team to build a real-time predictive maintenance application”
— Jonathan Wilkinson, CTO, Airdale
Baptiste Quidet Quidios
“We're able to collect and process new data in milliseconds, giving us an advantage others cannot match”
— Baptiste Quidet, Founder and Lead Data Scientist, Quideos
Ben Gamble Aiven
“Quix is one of the more interesting options because its more or less Faust 2.0 - pure Python with the annoying bits handled”
— Ben Gamble, Developer Advocate, Aiven
Christoph Dietrich Proreactware
“Instate of spending months with research and unknown costs afterwards, we use Quix as our nervous system for a real time trading platform with high performance infrastructure and deploy engine. The tech support behind Quix is pretty awesome.”
— Christoph Dietrich, Founder & Lead Software Engineer, proreactware

It’s free to get started

Try for free. Simply sign up with:

Background Graphic

Google

Sign Up
Background Graphic

GitHub

GitHub
Background Graphic

Microsoft

Microsoft

Talk to a technical expert about your use case if you’re considering using stream processing in your business.

Book a demo

the stream

Connect with the Quix Community

Get your questions answered in our community Slack channel, chat with us face-to-face at an event, or contribute to our open source connectors on GitHub.

Background Graphic