Compliance you can trust.
Imagine a night three years ago when a bank’s anti-money laundering system accidentally cleared a transaction. Now the auditors have shown up, and your leadership wants to know exactly why. The rules have changed, the data is gone, and the subject matter expert has moved on. How long until you can produce a full root cause analysis?
With a classical system, you’re lucky to have traces and logs. With ObzenFlow, you have a fully replayable tape.
Keep reading.
Learn how every stage here maintains a durable, append-only output tape, and everything written to its tape becomes execution instructions downstream. That’s how you build an audit-friendly durable workflow.
Run the demo yourself.
ObzenFlow's own overnight monitoring example runs one synthetic day of transactions against a simulated risk engine and case system, with nothing to install but Cargo.
Four ways ObzenFlow helps you navigate every audit.
Challenges with monitoring
Where ObzenFlow fits
Make every risk engine call a first-class effect.
Each verdict is recorded with the transaction, history and rules version behind it rather than reconstructed later.
Never silently drop another transaction.
Processing guarantees like “exactly once” are explicit, and the framework has dedicated error channels for remediation.
Delivery guarantees are validated.
A lost record fails a check immediately. This avoids surprises years after a run.
Replay any past run from its archive.
ObzenFlow archives are an audit superpower. They are executable journals, and far more powerful than logging.
Make every risk engine call a first-class effect.
In ObzenFlow, an external integration, like one with an AML rules engine, is a first-class side effect handled by the framework’s algebraic effects system. This system allows all non-deterministic code to safely run during live processing, but also safely replay during audit and even resume after an unforeseen crash. It handles all of these scenarios elegantly. You usually can’t read the rules inside a vendor’s engine, so the only way to explain a verdict is to show the request score sent and the response it got back. ObzenFlow records the response with its rules version, and the input and fingerprint that reproduce the request.
// risk_engine.rs
#[obzenflow::port]
#[async_trait]
pub trait RiskEnginePort {
#[effect(type = "aml.score_transaction", exactly_once)]
async fn score(
&self,
request: &ScoreRequest,
key: &IdempotencyKey,
ctx: &EffectContext,
) -> Result<outcome![TransactionCleared | AlertRaised], EffectError>;
}
// stages.rs
#[obzenflow::command(through = RiskEnginePort)]
#[derive(Clone, Debug)]
pub struct Scorer;
// flow.rs
stages: {
score = effectful_transform!(
ProfiledTransaction -> {
TransactionCleared,
AlertRaised,
ScoreUnavailable,
}
=> scorer
);
// …
},Never silently drop another transaction.
In ObzenFlow, every stage is an event-sourced state machine with two journals, one for
the records it produces and an error journal for the records it can’t process.
From the moment the source reads a transaction, every stage either processes it or
writes it to its error journal, and obzenflow show lists and counts every record in
an error journal, so a rejected transaction is in the morning’s count.
$ obzenflow show "$RUN"
SOURCE ERROR (stage: transactions, error journal: 19)
runtime.source.record_rejected ← transactions()
Stage Data records Error records
account_history 91 0
fx_rates 138 0
transactions 276 3 Validation
alerts 12 0
daily_profile 4 0
day_totals 1 0
open_case 12 0
price 276 0
profile 276 0
score 276 0
case_register 12 0
cleared 268 0
totals_report 1 0
unopened_alerts 0 0
unscored 0 0
Records in an error journal were delivered but not processed.
Delivery guarantees are validated.
In ObzenFlow, every edge carries a transport contract, and every edge into a register carries a delivery contract too. At the end of the night the runtime reconciles every handoff against the journals, with no code from you. transactions wrote 276 records and profile read 276. open_case sent 12 cases and case_register receipted all 12, none missing. Each result is journaled with the night, so a handoff that loses a record fails that night rather than six years later.
RUNTIME (stage: profile, journal: 10)
runtime.contract.verification_passed ← profile
⋮
{
"upstream": "transactions",
"upstream_journal": 4,
"contract_name": "TransportContract",
"phase": "final",
"advertised_writer_seq": 276,
"consumed_count": 276
}
RUNTIME (stage: case_register, journal: 12)
runtime.contract.verification_passed ← case_register
⋮
{
"upstream": "open_case",
"upstream_journal": 8,
"contract_name": "DeliveryContract",
"phase": "final",
"consumed_total": 12,
"receipted_total": 12,
"missing_count": 0,
"orphan_count": 0
}
Play back any past night, then run it again under new rules.
In ObzenFlow, every run is archived with evidence of all inputs, outputs and decisions made. This follows formal automata theory and is how this works without locking you into databases to support it. A manifest is written during every run which contains all journals, and those journals are replayable tapes.
Play the night back
--replay-fromreplays a historical manifest regardless of how much time has gone by. Preserve the manifest on long-term storage and audit years later. The effects system makes sure you can replay even without access to a historical risk engine or case system.Run it again under new rules Coming soon
We’re building support for swapping out the systems you replay against, such as a risk engine running new rules. It’s the next big evolution of our algebraic effects system.
Build your next monitoring flow on ObzenFlow.
ObzenFlow is open source. Star the project to follow its progress, or start a tutorial and build something yourself.
Have a question? Ask it in GitHub Discussions.