Overview

What is Nussknacker

Nussknacker is a low-code visual tool for domain experts and developers to define and run real-time decisioning algorithms instead of implementing the decision logic directly in code.

In all IT systems, no matter the domain, decisions are made all the time. Which offer should a customer get? Who should receive a marketing message? Does this device need servicing? Is this a fraud?

Decision algorithms can be implemented directly in code, especially when they require high performance or integration with many data sources. But these algorithms also change frequently: a new product needs to be promoted, or previously suspicious activity turns out to be legitimate. In a code-based implementation, each such adjustment enters the software delivery cycle.

Nussknacker creates a productive division of responsibilities: domain experts define and refine decision logic, while developers focus on the broader software, data, and infrastructure challenges beyond the algorithm itself.

The resulting decision logic can be executed over event streams or batches of records, or exposed in a request-response model, with horizontal scalability and high availability. This makes Nussknacker suitable for a wide range of use cases in microservice-based and event-driven architectures.

Nussknacker high level view - one or more input records are transformed and enriched with data from external systems to support a decision.

Why Building Real-Time Algorithms Is Hard—and How Nussknacker Helps

A scenario composed of modular functional blocks that use expressions and parameters to implement real-time decision logic. 🔍 View full-size image

Technical Complexity Obscures Domain Logic

When real-time decision algorithms are implemented directly in code, their domain logic becomes intertwined with technical concerns such as event ingestion, state management, integrations, and deployment. This makes the logic harder for domain experts to understand and change, even when the underlying business rules are relatively straightforward.

Millions of domain experts already build computational logic using spreadsheets: formulas, calculations, and rules that derive results from data. Nussknacker brings similar directness to real-time decision logic, even when its execution involves complex technologies and integrations.

Nussknacker represents algorithms using prefabricated functional blocks, called components, combined with expressions. The blocks encapsulate technical concerns such as data sources and sinks, stateful processing, time windows, joins, and interactions with external systems.

Authors can therefore work directly with the domain-level structure of the algorithm and the meaning of the data, rather than with Flink operators or stream-processing mechanics. Only genuinely new capabilities require extending Nussknacker with additional components.

Slow Experimentation and Long Feedback Loops

Real-time decision algorithms usually evolve through experimentation: testing hypotheses, adjusting thresholds, refining logic, and trying alternative enrichment sources. In a conventional development cycle, every iteration requires implementation, deployment, and validation, making experimentation slow and expensive.

Nussknacker integrates authoring, validation, testing, execution, and observation, allowing many authoring-and-testing iterations to be completed in under a minute.

Raw Events Lack Business Context

Real-world event streams—such as call detail records (CDRs), clickstream events, and sensor data—often contain only a fraction of the information needed to make a meaningful decision. Many meaningful decisions depend on external context: customer profiles, risk scores, inventories, metadata, ML predictions.

Nussknacker integrates SQL queries, OpenAPI calls, and ML model invocation in a consistent way: each enrichment is expressed as a function call, blending naturally with the expression language and not increasing the structural complexity of the algorithm.

Low-Code Tools Often Sacrifice Engineering Discipline

Low-code tools can make development more accessible, but often at the cost of capabilities needed to build and maintain non-trivial logic: validation, type assistance, code completion, versioning, debugging, and reproducible testing. They may also impose a “glass ceiling,” beyond which more complex logic has to be rewritten in code.

Nussknacker’s Designer provides these capabilities directly within the visual authoring environment. Its expression language also allows authors to implement sophisticated logic without abandoning the scenario model, combining accessibility for domain experts with the discipline expected in professional engineering workflows.

Limited Visibility into Algorithm Behavior

Conventional monitoring typically shows whether a system is healthy: throughput, latency, errors, or Kafka lag. It does not explain why a particular decision was made, which branch was taken, what intermediate values were calculated, or what values external enrichments returned.

Nussknacker exposes technical metrics, per-node event counts, and the values flowing through individual nodes during testing and debugging. This gives domain experts direct insight into how the decision logic behaves and provides developers with precise evidence when deeper technical investigation is required.

Production-Grade Execution Is Hard

Real-time algorithms must continue to produce correct results under high load, fluctuating traffic, backpressure, and infrastructure failures. Providing consistent state, horizontal scalability, and reliable recovery is difficult and should not have to be implemented separately for every algorithm.

Nussknacker delegates execution and operational concerns to proven runtime foundations, including Apache Flink, Kafka, and Kubernetes. The exact architecture depends on the selected processing mode and engine. This allows scenario authors to focus on decision logic, while platform and infrastructure teams manage a shared, production-grade foundation.

Streaming SQL Is Too Restrictive for Complex Decision Logic

Some stream-processing tools provide a graphical editor that ultimately generates SQL. This works well for relational transformations and simple pipelines, but becomes restrictive when decision logic requires branching, stateful processing, multiple enrichments, ML or LLM integration, and inspection of intermediate results.

Nussknacker does not generate SQL. For Flink-based execution, it builds on both Apache Flink’s Table API and DataStream API, combining relational-style operations with the richer control required for real-time decisioning. This makes it possible to construct sequences of decision steps that would be unnatural or impractical to express in SQL alone.

Use Cases

Nussknacker is typically embedded in a larger system, where it receives input data, evaluates it, and produces a decision or action. A scenario may filter and transform records, enrich them with external data, maintain state over time, detect patterns, invoke ML models, and deliver the result to another system.

Typical use cases include:

• fraud and anomaly detection;
• loan approval and other eligibility decisions;
• next-best-offer and real-time personalization;
• dynamic pricing;
• predictive maintenance and operational decisions based on IoT data;
• usage-based rating for telecommunications, cloud services, or gaming;
• ML-driven decisions requiring non-trivial preprocessing and post-processing.