www.quix.io Open in urlscan Pro
34.243.34.160  Public Scan

Form analysis
6 forms found in the DOM

<form>
  <fieldset>
    <legend class="visuallyhidden">Consent Selection</legend>
    <div id="CybotCookiebotDialogBodyFieldsetInnerContainer">
      <div class="CybotCookiebotDialogBodyLevelButtonWrapper"><label class="CybotCookiebotDialogBodyLevelButtonLabel" for="CybotCookiebotDialogBodyLevelButtonNecessary"><span
            class="CybotCookiebotDialogBodyLevelButtonDescription">Necessary</span></label>
        <div class="CybotCookiebotDialogBodyLevelButtonSliderWrapper CybotCookiebotDialogBodyLevelButtonSliderWrapperDisabled"><input type="checkbox" id="CybotCookiebotDialogBodyLevelButtonNecessary"
            class="CybotCookiebotDialogBodyLevelButton CybotCookiebotDialogBodyLevelButtonDisabled" disabled="disabled" checked="checked"> <span class="CybotCookiebotDialogBodyLevelButtonSlider"></span></div>
      </div>
      <div class="CybotCookiebotDialogBodyLevelButtonWrapper"><label class="CybotCookiebotDialogBodyLevelButtonLabel" for="CybotCookiebotDialogBodyLevelButtonPreferences"><span
            class="CybotCookiebotDialogBodyLevelButtonDescription">Preferences</span></label>
        <div class="CybotCookiebotDialogBodyLevelButtonSliderWrapper"><input type="checkbox" id="CybotCookiebotDialogBodyLevelButtonPreferences" class="CybotCookiebotDialogBodyLevelButton CybotCookiebotDialogBodyLevelConsentCheckbox"
            data-target="CybotCookiebotDialogBodyLevelButtonPreferencesInline" checked="checked" tabindex="0"> <span class="CybotCookiebotDialogBodyLevelButtonSlider"></span></div>
      </div>
      <div class="CybotCookiebotDialogBodyLevelButtonWrapper"><label class="CybotCookiebotDialogBodyLevelButtonLabel" for="CybotCookiebotDialogBodyLevelButtonStatistics"><span
            class="CybotCookiebotDialogBodyLevelButtonDescription">Statistics</span></label>
        <div class="CybotCookiebotDialogBodyLevelButtonSliderWrapper"><input type="checkbox" id="CybotCookiebotDialogBodyLevelButtonStatistics" class="CybotCookiebotDialogBodyLevelButton CybotCookiebotDialogBodyLevelConsentCheckbox"
            data-target="CybotCookiebotDialogBodyLevelButtonStatisticsInline" checked="checked" tabindex="0"> <span class="CybotCookiebotDialogBodyLevelButtonSlider"></span></div>
      </div>
      <div class="CybotCookiebotDialogBodyLevelButtonWrapper"><label class="CybotCookiebotDialogBodyLevelButtonLabel" for="CybotCookiebotDialogBodyLevelButtonMarketing"><span
            class="CybotCookiebotDialogBodyLevelButtonDescription">Marketing</span></label>
        <div class="CybotCookiebotDialogBodyLevelButtonSliderWrapper"><input type="checkbox" id="CybotCookiebotDialogBodyLevelButtonMarketing" class="CybotCookiebotDialogBodyLevelButton CybotCookiebotDialogBodyLevelConsentCheckbox"
            data-target="CybotCookiebotDialogBodyLevelButtonMarketingInline" checked="checked" tabindex="0"> <span class="CybotCookiebotDialogBodyLevelButtonSlider"></span></div>
      </div>
    </div>
  </fieldset>
</form>

---

<form><input type="checkbox" id="CybotCookiebotDialogBodyLevelButtonNecessaryInline" class="CybotCookiebotDialogBodyLevelButton CybotCookiebotDialogBodyLevelButtonDisabled" disabled="disabled" checked="checked"> <span
    class="CybotCookiebotDialogBodyLevelButtonSlider"></span></form>

---

<form><input type="checkbox" id="CybotCookiebotDialogBodyLevelButtonPreferencesInline" class="CybotCookiebotDialogBodyLevelButton CybotCookiebotDialogBodyLevelConsentCheckbox" data-target="CybotCookiebotDialogBodyLevelButtonPreferences"
    checked="checked" tabindex="0"> <span class="CybotCookiebotDialogBodyLevelButtonSlider"></span></form>

---

<form><input type="checkbox" id="CybotCookiebotDialogBodyLevelButtonStatisticsInline" class="CybotCookiebotDialogBodyLevelButton CybotCookiebotDialogBodyLevelConsentCheckbox" data-target="CybotCookiebotDialogBodyLevelButtonStatistics"
    checked="checked" tabindex="0"> <span class="CybotCookiebotDialogBodyLevelButtonSlider"></span></form>

---

<form><input type="checkbox" id="CybotCookiebotDialogBodyLevelButtonMarketingInline" class="CybotCookiebotDialogBodyLevelButton CybotCookiebotDialogBodyLevelConsentCheckbox" data-target="CybotCookiebotDialogBodyLevelButtonMarketing" checked="checked"
    tabindex="0"> <span class="CybotCookiebotDialogBodyLevelButtonSlider"></span></form>

---

<form class="CybotCookiebotDialogBodyLevelButtonSliderWrapper"><input type="checkbox" id="CybotCookiebotDialogBodyContentCheckboxPersonalInformation" class="CybotCookiebotDialogBodyLevelButton"> <span
    class="CybotCookiebotDialogBodyLevelButtonSlider"></span></form>

---

Text Content

Powered by Cookiebot
 * Consent
 * Details
 * [#IABV2SETTINGS#]
 * About


COOKIES, YUM!

Your data, your choice. We use cookies to enhance your experience and improve
our site. Here's our privacy policy.
Consent Selection
Necessary

Preferences

Statistics

Marketing

Show details
Necessary 9

Necessary cookies help make a website usable by enabling basic functions like
page navigation and access to secure areas of the website. The website cannot
function properly without these cookies.
Cookiebot
1
Learn more about this provider
CookieConsentStores the user's cookie consent state for the current domain
Expiry: 1 yearType: HTTP
Google
1
Learn more about this provider
test_cookieUsed to check if the user's browser supports cookies.
Expiry: 1 dayType: HTTP
Hubspot
2
Learn more about this provider
embed/v3/counters.gif [x2]Used to implement forms on the website.
Expiry: SessionType: Pixel
Vimeo
1
Learn more about this provider
__cf_bmThis cookie is used to distinguish between humans and bots. This is
beneficial for the website, in order to make valid reports on the use of their
website.
Expiry: 1 dayType: HTTP
cdn.jsdelivr.net
1
algoliasearch-client-jsNecessary in order to optimize the website's search-bar
function. The cookie ensures accurate and fast search results.
Expiry: PersistentType: HTML
play.google.com
youtube.com

2
CONSENT [x2]Used to detect if the visitor has accepted the marketing category in
the cookie banner. This cookie is necessary for GDPR-compliance of the website.
Expiry: 2 yearsType: HTTP
www.quix.io
1
cache-sprite-plyrThis cookie is necessary for the cache function. A cache is
used by the website to optimize the response time between the visitor and the
website. The cache is usually stored on the visitor’s browser.
Expiry: PersistentType: HTML
Preferences 1

Preference cookies enable a website to remember information that changes the way
the website behaves or looks, like your preferred language or the region that
you are in.
www.quix.io
1
plyrNecessary for the implementation of video-content on the website.
Expiry: PersistentType: HTML
Statistics 20

Statistic cookies help website owners to understand how visitors interact with
websites by collecting and reporting information anonymously.
Akamai Technologies
1
Learn more about this provider
aka_debugUsed by Vimeo to track usage of their embedded video player.
Expiry: SessionType: HTTP
Google
3
Learn more about this provider
_gaRegisters a unique ID that is used to generate statistical data on how the
visitor uses the website.
Expiry: 399 daysType: HTTP
_ga_#Used by Google Analytics to collect data on the number of times a user has
visited the website as well as dates for the first and most recent visit.
Expiry: 399 daysType: HTTP
_gidRegisters a unique ID that is used to generate statistical data on how the
visitor uses the website.
Expiry: 1 dayType: HTTP
Hotjar
7
Learn more about this provider
_hjAbsoluteSessionInProgressThis cookie is used to count how many times a
website has been visited by different visitors - this is done by assigning the
visitor an ID, so the visitor does not get registered twice.
Expiry: 1 dayType: HTTP
_hjFirstSeenThis cookie is used to determine if the visitor has visited the
website before, or if it is a new visitor on the website.
Expiry: 1 dayType: HTTP
_hjRecordingLastActivitySets a unique ID for the session. This allows the
website to obtain data on visitor behaviour for statistical purposes.
Expiry: SessionType: HTML
_hjSession_#Collects statistics on the visitor's visits to the website, such as
the number of visits, average time spent on the website and what pages have been
read.
Expiry: 1 dayType: HTTP
_hjSessionUser_#Collects statistics on the visitor's visits to the website, such
as the number of visits, average time spent on the website and what pages have
been read.
Expiry: 1 yearType: HTTP
_hjTLDTestRegisters statistical data on users' behaviour on the website. Used
for internal analytics by the website operator.
Expiry: SessionType: HTTP
hjViewportIdSets a unique ID for the session. This allows the website to obtain
data on visitor behaviour for statistical purposes.
Expiry: SessionType: HTML
New Relic
2
Learn more about this provider
events/1/#Used to monitor website performance for statistical purposes.
Expiry: SessionType: Pixel
jserrors/1/#Pending
Expiry: SessionType: Pixel
Vimeo
1
Learn more about this provider
vuidCollects data on the user's visits to the website, such as which pages have
been read.
Expiry: 399 daysType: HTTP
portal.platform.quix.ai
script.hotjar.com

4
_hjIncludedInPageviewSample [x2]Used to detect whether the user navigation and
interactions are included in the website’s data analytics.
Expiry: 1 dayType: HTTP
_hjIncludedInSessionSample [x2]Registers data on visitors' website-behaviour.
This is used for internal analysis and website optimization.
Expiry: 1 dayType: HTTP
quix.ai
www.google-analytics.com

2
_gat [x2]Used by Google Analytics to throttle request rate
Expiry: 1 dayType: HTTP
Marketing 19

Marketing cookies are used to track visitors across websites. The intention is
to display ads and content that are relevant to users.
Google
6
Learn more about this provider
IDEUsed by Google DoubleClick to register and report the website user's actions
after viewing or clicking one of the advertiser's ads with the purpose of
measuring the efficacy of an ad and to present targeted ads to the user.
Expiry: 1 yearType: HTTP
pagead/landing [x2]Collects data on visitor behaviour from multiple websites, in
order to present more relevant advertisement - This also allows the website to
limit the number of times that they are shown the same advertisement.
Expiry: SessionType: Pixel
pagead/viewthroughconversion/10896568703Pending
Expiry: SessionType: Pixel
pagead/1p-conversion/#Collects data on visitor behaviour from multiple websites,
in order to present more relevant advertisement - This also allows the website
to limit the number of times that they are shown the same advertisement.
Expiry: SessionType: Pixel
_gcl_auUsed by Google AdSense for experimenting with advertisement efficiency
across websites using their services.
Expiry: 3 monthsType: HTTP
Hotjar
1
Learn more about this provider
_hjRecordingEnabledThis cookie is used to identify the visitor and optimize
ad-relevance by collecting visitor data from multiple websites – this exchange
of visitor data is normally provided by a third-party data-center or
ad-exchange.
Expiry: SessionType: HTML
Vimeo
1
Learn more about this provider
NRBA_SESSION_IDCollects user data through quiz/survey-like content. This allows
the website to promote relevant products or services.
Expiry: SessionType: HTML
YouTube
11
Learn more about this provider
DEVICE_INFOPending
Expiry: 179 daysType: HTTP
VISITOR_INFO1_LIVETries to estimate the users' bandwidth on pages with
integrated YouTube videos.
Expiry: 179 daysType: HTTP
YSCRegisters a unique ID to keep statistics of what videos from YouTube the user
has seen.
Expiry: SessionType: HTTP
ytidb::LAST_RESULT_ENTRY_KEYStores the user's video player preferences using
embedded YouTube video
Expiry: PersistentType: HTML
yt-remote-cast-availableStores the user's video player preferences using
embedded YouTube video
Expiry: SessionType: HTML
yt-remote-cast-installedStores the user's video player preferences using
embedded YouTube video
Expiry: SessionType: HTML
yt-remote-connected-devicesStores the user's video player preferences using
embedded YouTube video
Expiry: PersistentType: HTML
yt-remote-device-idStores the user's video player preferences using embedded
YouTube video
Expiry: PersistentType: HTML
yt-remote-fast-check-periodStores the user's video player preferences using
embedded YouTube video
Expiry: SessionType: HTML
yt-remote-session-appStores the user's video player preferences using embedded
YouTube video
Expiry: SessionType: HTML
yt-remote-session-nameStores the user's video player preferences using embedded
YouTube video
Expiry: SessionType: HTML
Unclassified 0
Unclassified cookies are cookies that we are in the process of classifying,
together with the providers of individual cookies.

We do not use cookies of this type.

Cross-domain consent[#BULK_CONSENT_DOMAINS_COUNT#] [#BULK_CONSENT_TITLE#]
List of domains your consent applies to: [#BULK_CONSENT_DOMAINS#]
Cookie declaration last updated on 23.12.22 by Cookiebot


[#IABV2_TITLE#]

[#IABV2_BODY_INTRO#]
[#IABV2_BODY_LEGITIMATE_INTEREST_INTRO#]
[#IABV2_BODY_PREFERENCE_INTRO#]
[#IABV2_LABEL_PURPOSES#]
[#IABV2_BODY_PURPOSES_INTRO#]
[#IABV2_BODY_PURPOSES#]
[#IABV2_LABEL_FEATURES#]
[#IABV2_BODY_FEATURES_INTRO#]
[#IABV2_BODY_FEATURES#]
[#IABV2_LABEL_PARTNERS#]
[#IABV2_BODY_PARTNERS_INTRO#]
[#IABV2_BODY_PARTNERS#]

Cookies are small text files that can be used by websites to make a user's
experience more efficient.

The law states that we can store cookies on your device if they are strictly
necessary for the operation of this site. For all other types of cookies we need
your permission.

This site uses different types of cookies. Some cookies are placed by third
party services that appear on our pages.

You can at any time change or withdraw your consent from the Cookie Declaration
on our website.


Do not sell or share my personal information
Deny Allow selection Customize

Allow all
Powered by Cookiebot by Usercentrics
 * Product
 * Use Cases
 * Pricing
 * Company
 * Blog
 * Community

PRODUCT OVERVIEW
 * For Data Processing Pipelines
 * For Event-Driven Back Ends
 * Compare Quix
 * Streaming demo
 * Service Status

Use Cases
 * Finance
 * Gaming
 * Mobility
 * Ecommerce
 * Telco
 * Media
 * Data science
 * Data engineering


COMPANY OVERVIEW
 * Careers
 * Diversity & inclusion
 * Environmental statement



Docs Sign Up Login

Product
Product Overview
 * For Data Processing Pipelines
 * For Event-Driven Back Ends
 * Compare Quix
 * Streaming demo
 * Service Status

Use Cases
Use Cases Overview
 * Finance
 * Gaming
 * Mobility
 * Ecommerce
 * Telco
 * Media
 * Data science
 * Data engineering

Pricing
Company
Company Overview
 * Careers
 * Diversity & inclusion
 * Environmental statement

Blog
Community
Docs
Sign Up Login


DEVELOP REAL-TIME DATA APPS AND SERVICES FASTER

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

Start Building Read the docs
View code library in GitHub

99.872%

Uptime (90 days)

57tb

Processed

1390

Developers

934

Organizations



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.



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
Finance Manufacturing Mobility
INGEST Connect your source ENRICH Transform raw data EXECUTE Detect fraud
PERSIST Send to destination
app.py
app.cs

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.

app.py
app.cs

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.

app.py
app.cs

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.

app.py
app.cs

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.

INGEST Connect your source ENRICH Transform raw data EXECUTE Detect degradation
PERSIST Send to destination
app.py
app.cs

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.

app.py
app.cs

// 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.

app.py
app.cs

// 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.

app.py
app.cs

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

INGEST Connect your source ENRICH Transform raw data EXECUTE Detect hazards
PUBLISH Send to destination
app.py
app.cs

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.

app.py
app.cs

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.

app.py
app.cs

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.

app.py
app.cs

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


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



OPTIMIZING MANUFACTURING EFFICIENCY

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



1

platform

3

developers

4

applications

Learn more



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


THE PRODUCT


WHAT MAKES QUIX SO POWERFUL?

Discover the product

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.

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.

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.

“Quix has given us an environment to handle a huge amount of real-time machine
data.”
— Chris Angell, Lead Systems Engineer, CloudNC
“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
“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
“Quix saved us from hiring a whole data engineering team to build a real-time
predictive maintenance application”
— Jonathan Wilkinson, CTO, Airdale
“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
“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
“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
“Quix has given us an environment to handle a huge amount of real-time machine
data.”
— Chris Angell, Lead Systems Engineer, CloudNC
“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
“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
“Quix saved us from hiring a whole data engineering team to build a real-time
predictive maintenance application”
— Jonathan Wilkinson, CTO, Airdale
“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
“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
“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:

GOOGLE

Sign Up

GITHUB

GitHub

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.

Slack Twitter Quix GitHub


The easiest way to build and scale reliable data applications.

Try for free Docs
Copyright © 2023 Quix Analytics

PRODUCT

 * Features
 * Use Cases
 * Pricing
 * Streaming demo
 * Compare Quix
 * Service status

DEVELOPER SUPPORT

 * Docs
 * YouTube tutorials
 * SDK
 * Quix GitHub
 * The Stream community
 * Changelog

ABOUT

 * The company
 * Blog
 * Careers
 * Diversity & inclusion
 * Environmental statement

CONNECT

 * Book a demo
 * Slack community

 * Terms
 * Privacy
 * License Terms

Follow us:

 * 
 * 
 * 
 *