Apache Storm is one of the original distributed real-time computation systems. It processes unbounded streams of data with very low latency, one tuple at a time, and was widely deployed (notably at Twitter) before the current generation of stream processors existed. Its model is a directed graph of processing steps called a topology, and understanding Storm is useful both historically and because its concepts still appear in newer systems.

Topologies: spouts and bolts

A Storm topology is a graph where spouts are sources that emit streams of tuples and bolts are processing nodes that transform, aggregate, or write them. You wire spouts to bolts and bolts to other bolts, and Storm runs the graph continuously across a cluster. Stream groupings control how tuples are routed between components - a fieldsGrouping sends tuples with the same key to the same bolt instance, which is how you keep related data together for aggregation.

builder.setSpout("events", new KafkaSpout(), 4);
builder.setBolt("parse", new ParseBolt(), 8)
       .shuffleGrouping("events");
builder.setBolt("count", new CountBolt(), 8)
       .fieldsGrouping("parse", new Fields("userId"));

Delivery guarantees

Storm's core model gives at-least-once delivery through tuple acking: each tuple is tracked through the topology, and if it isn't fully processed within a timeout, the spout replays it. For stronger semantics, the Trident API layers exactly-once, stateful, micro-batch processing on top. The base model's low per-tuple latency is its strength; the lack of built-in exactly-once in core Storm is why many teams moved to newer engines.

Where it stands

Storm proved that real-time stream processing at scale was possible, but Apache Flink and Spark Streaming have largely taken its place for new projects, offering richer state management and exactly-once out of the box. Storm topologies still run in production, and its spout-and-bolt vocabulary remains a clear way to think about streaming dataflow.

Frequently asked questions

What are spouts and bolts? Spouts are stream sources that emit tuples; bolts are processing nodes that transform or aggregate them. A topology is the graph wiring them together.

What delivery guarantee does Storm give? At-least-once by default via tuple acking and replay; exactly-once and stateful processing come from the Trident API on top.

Should I choose Storm today? For new work, Flink or Spark Streaming usually win on state and exactly-once; Storm remains in existing deployments and is still a clean mental model for streaming dataflow.