Events rarely arrive in the order they happened. Webhooks get retried, so the same event shows up twice. Device clocks drift, so a payment looks older than the order it paid for. A market feed handler sees tick 88 before tick 87. Most teams patch it with a dedupe table, a sort buffer and a timeout, and the patch mostly works.
The trouble shows up on the second run. A backfill, an audit, a bug hunt, or two systems that are supposed to agree, and the patched pipeline produces a slightly different sequence each time, with no clear cause. Inorderly fixes that. It takes the events, drops the repeats and releases them as one sequence that’s a fixed function of the input. Run it again on the same events, in any arrival order, with any duplicates, and you get the same output, byte for byte.
The Pitch in Four Numbers
- 200,000 shuffled arrival orders of 10,000 tangled event sets, with repeats and restores, and every set gave one output.
- 30 hard kills at random moments in one checkpointed run, and the output still matched an uninterrupted run byte for byte.
- 344,000 events a second put in order on two cores, with two-thirds of them repeats.
- 1 SHA-256 hash that lets anyone check two runs agree, even with plain
sha256sum.
How It Works
Inorderly holds events in a bounded window until the newest event time has moved a set distance past them. Anything that arrives later than that is refused and reported, never slipped in, so late events can’t change the output of on-time ones. The order is published: time, then a hybrid logical clock counter, then producer, sequence number and id. Rules you can read, not a buffer’s mood.
An event can name the events it depends on. It waits for them, for a bounded time, and lands after them even if its own clock is behind. Parents that never arrive are listed in the output. Identical events count as one. Different events that share an identity are reported as conflicts, never quietly merged.
The inorderly command reads and writes NDJSON, so any language can feed it, and Go programs can embed the library. With checkpoints on, a killed run resumes and writes exactly what an uninterrupted run would. It can also read from and write to Kafka, NATS JetStream and Redis Streams, keeping its own checkpoints instead of relying on consumer groups. Producers that use the bundled clock package give each child a timestamp above its parents’, so nothing has to wait.
Who It’s For
- Payment and webhook pipelines where a retry must never become a second charge.
- Ledgers and billing, where replaying history has to give the same balance every time.
- Market data with gaps and reordering from feed handlers.
- Sensor telemetry from devices whose clocks can’t be trusted.
Limits
It orders one stream in one process, from any number of inputs. To scale, run one instance per stream, split the way your data already splits. Producers need integer timestamps. And it isn’t a server, a database, a broker or a full stream processing engine. It does the ordering step and nothing else.
The Four-Question Screening
Every project featured here gets the same four questions, the way you’d screen a startup idea.
1. Where is the money in it?
Inorderly is free under Apache 2.0, with no paid tier. The money is where wrong order is expensive: payments, trading, billing and anything audited. Those teams pay for correctness they can prove to an auditor. The paid paths are support contracts, a managed version that runs alongside their brokers, certified builds for regulated environments and connectors beyond the three brokers it reads today. Verification, showing two systems agree with a hash, is a service in itself.
2. What real problem does it solve?
Replays that don’t match. A pipeline that gives a slightly different answer each time it’s re-run can’t be audited or debugged, and nobody can say why. Inorderly turns ordering into a documented, repeatable function with a hash to prove it.
3. The technology in plain words
Think of a pile of letters that arrive out of order, some twice, some late. Inorderly is the clerk who sorts them by the date written inside, throws away the copies, files a note about the ones that came too late, and lays them out in a row. Give the same pile to the same clerk tomorrow, shuffled differently, and the row comes out identical.
4. Moat and differentiation
Kafka keeps order inside one partition, not across partitions, and can’t recognise an upstream retry as the same event. Flink and Beam order events with watermarks, but as part of a whole processing engine you have to deploy and run. Inorderly does only the ordering step, as a library or a command, with published rules and a verifiable hash. Small, provable and easy to drop into an existing pipeline. The moat that can grow is the reputation for exact replays and the broker connectors that make adoption easy.
Why It Matters
Every audit, backfill and reconciliation assumes that running the same data twice gives the same answer. Most pipelines can’t promise that. A small step that makes order deterministic, and proves it, fixes a whole class of bugs nobody can reproduce.
Follow the Project
Read what deterministic event ordering is, start with the quick start, browse the use cases, see how it was tested, or get the code from the Inorderly repository on GitHub. Inorderly is listed with the other open-source projects on SoftDevStudio.com, and more featured projects are in the Projects section.