FIRE Architecture in Practice

SUMMARY

Jim Callahan, a veteran functional programmer at Splash Financial, presents FIRE, a novel event-sourced, graph-based architecture built in Clojure to overhaul fintech systems for reliable HELOC lending, addressing technical debt and enabling safe innovation.

STATEMENTS

Splash Financial acts as a middleman in fintech, handling student loans, personal loans, and recently home equity lines of credit, with about 40 developers and 150 total employees.
High-stakes decisions in lending, such as approving half-million-dollar loans, demand extreme reliability, correctness in computations, auditability for errors, and secure handling of sensitive data.
The market's constant evolution requires safe experimentation with loan processes without disrupting existing functionality, influencing the design of their architecture.
FIRE represents an evolution of event sourcing and CQRS, where state is derived from immutable facts and pure functions, allowing re-evaluation and full historical tracking.
Traditional event sourcing often leads to complex finite state machines and distributed services that are hard to reason about, debug, and operate, especially with hundreds of interactions.
In FIRE, processes are modeled as explicit graphs of pure functions with defined data flows, centralizing business logic and event storage in a single service for fast evaluation.
Observations in FIRE are ground-truth facts from external sources like customers, underwriters, or credit services, triggering reactive graph evaluations stored transactionally.
Graph nodes not only compute values but also signal needs for fresher input data, enabling backward tracing to drive acquisition of new observations via commands to front-end or observer services.
The system operates in a rinse-and-repeat cycle: evaluate new observations, check for conclusions, and if incomplete, identify and acquire missing data asynchronously.
Inferences are pure Clojure functions that derive new events from observations, committed in generations, while exceptions can reject invalid inputs to maintain control over event ingestion.
Commands capture side-effect information without executing them, producing events that observer microservices consume via Kafka to perform external interactions and generate new observations.
FIRE enabled a small team to build and launch a new HELOC product in seven months, with superior productivity, performance, no major incidents, and enhanced security.
Hydrant, a custom visualization tool, extends IDEs, facilitates product-engineer collaboration, and aids production debugging by displaying graphs, events, and data flows.
Attributes are defined using Malli with global namespaces, including validation, sensitivity classification, and documentation, applied consistently across all events.
End-to-end envelope encryption protects all payloads in databases and Kafka, treating data as highly sensitive regardless of actual classification.
Local development is supported by pluggable modules using Integrant, allowing in-memory replacements for databases, enabling offline testing and rapid iteration cycles.
Code immutability ensures production nodes in dedicated namespaces remain unchanged, supporting versioned graphs for safe experimentation and A/B testing without regressions.
Projections from Kafka events enable inventory, reporting, and analytics, with data streamed to Snowflake for warehousing, unlocking further applications.

IDEAS

Representing business processes as explicit graphs rather than opaque state machines simplifies reasoning about data flows in complex, high-risk domains like lending.
Using exceptions in pure functions to reject unwanted late inputs provides fine-grained control over event streams, preventing invalid state changes post-decision.
Centralizing logic in a monolith for graph evaluation achieves low-latency performance without scalability worries for moderate-throughput fintech applications.
Backward propagation from graph nodes to identify acquisition needs creates a dynamic, self-directing data-gathering process that adapts to incomplete information.
Commands decouple side effects entirely from core evaluation, allowing asynchronous external interactions while maintaining pure, synchronous consistency in the graph.
Versioning entire graphs immutably enables running multiple product versions or experiments side-by-side without interference, fostering innovation in evolving markets.
Hydrant's real-time visualization turns abstract event graphs into intuitive, inspectable trees, bridging the gap between engineers, product teams, and business stakeholders.
Separating observations into granular attributes allows front-ends to remix and present data flexibly, achieving extreme decoupling that speeds UI iteration.
Pluggable, in-memory local setups with data specifications enable exhaustive, generative testing offline, reducing reliance on staging environments.
Treating node code as immutable libraries post-deployment ensures historical applications remain stable, even as new experiments proliferate.
Early integration of visualization tools like Hydrant during design phases accelerates collaborative graph building with non-technical stakeholders.
Envelope encryption on all event payloads standardizes security, eliminating case-by-case sensitivity judgments in data handling.
Projections from event streams power diverse downstream uses like analytics, turning the architecture into a versatile data backbone beyond core processing.

INSIGHTS

Explicit graph structures demystify complex interactions, transforming debugging from guesswork into traceable data paths, essential for auditability in regulated industries.
Reactive acquisition cycles mimic human decision-making, iteratively filling knowledge gaps until resolution, optimizing resource use in uncertain processes like loan underwriting.
Immutability at both data and code levels creates a tamper-proof historical record, enabling safe rewinds and experiments without risking live systems.
Total decoupling of synchronous evaluation from asynchronous I/O enforces purity, yielding predictable behavior that bolsters confidence in high-stakes computations.
Visualization tools as collaborative artifacts empower non-engineers to co-design logic, shortening feedback loops and aligning technical implementations with business intent.
Versioned, parallel deployments treat architectures like evolving libraries, allowing controlled innovation waves that preserve legacy stability in dynamic markets.
Granular, classified attributes with built-in documentation foster consistent data governance, reducing errors in sensitive, multi-source fintech pipelines.
Local, pluggable development environments democratize testing, accelerating velocity by minimizing infrastructure dependencies and enabling creative exploration.
Centralized yet performant monoliths challenge microservices dogma, proving simplicity scales well for bounded, event-driven domains without distributed complexity.
Exception-driven rejection mechanisms extend validation beyond syntax to semantics, enforcing business rules proactively in reactive event flows.

QUOTES

"You make a loan for half a million dollars to the wrong person that has a big deal."
"Event sourcing is the idea you have a set of facts from the world. You have some sort of computation that updates a kind of aggregate state."
"We represent a process as a set of these pure functions. But there are explicit steps between them. So we know exactly which data flows through which steps."
"The graph has this interesting characteristic it's not just one way. Each node in the graph in addition to returning value also returns which of its inputs it would like to have fresher values on."
"It was so ridiculously decoupled that I think at the time of launch we had never actually run the front end and the back end together."
"Our code is immutable too. So when we release a node into production we the source code is in it own namespace and we never touch that namespace again."
"We managed to build a new product that we launched in the spring uh in about 7 months. Um it was remarkably more productive than our previous architectures."

HABITS

Prioritizing functional programming and distributed systems throughout a 30-year career, blending them for modern architectures like FIRE.
Driving short distances to conferences to maintain work-life balance while staying engaged in the Clojure community.
Assuming audience alignment on key principles to focus talks on core innovations, saving time for demonstrations.
Developing visualization tools early in projects to facilitate ongoing collaboration with product and business teams.
Conducting 80% of development locally with pluggable modules, minimizing staging use for faster iteration.
Treating code changes as new library versions, avoiding modifications to production namespaces to ensure stability.

FACTS

Splash Financial processes single-digit thousands of loan applications daily, focusing on quality over massive throughput in high-risk fintech.
The HELOC product was built and launched in seven months by a small team using FIRE, contrasting with legacy systems bogged down by technical debt.
Graph evaluations in FIRE complete in low hundreds of milliseconds, suitable for cloud-native Clojure environments without scalability bottlenecks.
Hydrant was developed in the first month of the project and used throughout for real-time graph building in Zoom meetings with stakeholders.
End-to-end encryption covers all event payloads in PostgreSQL and Kafka, enhancing security beyond previous architectures.
On launch day, a bug was identified and fixed in 10 minutes using Hydrant, highlighting its debugging efficacy.

REFERENCES

Clojure: Primary language for pure functions, inferences, and overall implementation.
Kafka: Used for event streaming between the central service and observer microservices.
PostgreSQL: Database for transactional storage of observations and inferences, with Debezium for change data capture.
Hydrant: Custom graph/event visualization tool for collaboration, development, and production debugging.
Malli: Schema library for defining attributes with validation, classification, and documentation.
Integrant: Dependency injection framework for assembling pluggable modules in local and production setups.
Portal: Embedded in Hydrant for data inspection of nodes.
Snowflake: Data warehouse for projections, reporting, and analytics from Kafka events.
TypeScript library: Employed in Hydrant for graph drawing functionality.
Marshall: Internal tool for testing and simulating applications like creating test users.

HOW TO APPLY

Model business processes as explicit graphs of pure functions, defining data flows to replace implicit state machines and clarify interactions.
Ingest external facts as observations, triggering synchronous graph evaluations that derive inferences and store them transactionally in a centralized database.
Implement node functions to return both computed values and requests for fresher inputs, enabling backward tracing to generate acquisition commands.
Use commands to queue asynchronous side effects without executing them in the core graph, routing via event streams to specialized observer services.
Version graphs and nodes immutably in dedicated namespaces, allowing parallel deployment of experiments while preserving legacy behavior.

ONE-SENTENCE TAKEAWAY

FIRE's graph-based, immutable event architecture revolutionizes fintech by ensuring reliable, auditable innovation without legacy disruptions.

RECOMMENDATIONS

Adopt explicit graph modeling for complex processes to enhance traceability and reduce debugging complexity in regulated domains.
Centralize pure evaluations in a performant monolith for domains with moderate scale, avoiding premature microservices distribution.
Develop visualization tools early to involve non-technical stakeholders in design, accelerating alignment and iteration.
Enforce immutability on code and data post-deployment to enable safe, parallel experimentation across product versions.
Standardize attribute schemas with sensitivity tags and encryption to streamline secure data handling across systems.
Leverage local, pluggable environments for 80% of development, prioritizing offline testing to boost velocity.
Use exceptions semantically in pure functions to reject invalid events, extending control beyond basic validation.
Stream events for projections into analytics tools, transforming core logic into a multi-purpose data foundation.

MEMO

In the high-stakes world of fintech, where a single misstep can cost hundreds of thousands of dollars, Splash Financial faced a reckoning after years of rapid growth left their systems mired in technical debt. As a broker connecting lenders and borrowers in student loans, personal loans, and now home equity lines of credit, the company—home to about 150 people, including 40 developers—knew it needed a radical overhaul. Enter Jim Callahan, a functional programming veteran with three decades of experience, who led the charge to design FIRE, an architecture blending event sourcing with graph-based evaluation. Presented at Clojure/conj 2025, Callahan's talk revealed how this system not only launched their first HELOC product in seven months but also restored engineering velocity while embedding reliability and auditability.

At its core, FIRE evolves traditional event sourcing—where state emerges from immutable facts processed through pure functions—by modeling processes as explicit graphs rather than tangled state machines. Observations, the raw truths from customers, underwriters, or credit bureaus, serve as leaves in a reactive tree. When one arrives, it triggers evaluation of downstream nodes, called inferences, which derive new events committed transactionally to a PostgreSQL database. This central monolith handles business logic swiftly, often in mere hundreds of milliseconds, sidestepping the distributed sprawl that plagues many systems. Commands, meanwhile, capture intents for side effects—like querying external services—without polluting the pure core, routing them asynchronously via Kafka to observer microservices that loop back new observations.

What sets FIRE apart is its bidirectional intelligence: nodes not only compute but signal unmet needs, tracing backward to dictate data acquisition. This rinse-and-repeat cycle mirrors decision-making in lending, where incomplete applications prompt targeted requests—say, a fresh phone number for credit pulls—without rigid sequences. Callahan demonstrated this with Hydrant, their bespoke visualization tool, which renders graphs as intuitive trees. In a live demo of a HELOC application, orange acquisition lines highlighted pending tasks like employment verification, while portals let inspectors drill into credit details. Built early with ClojureScript and embedded Portal, Hydrant bridged engineers and product teams, enabling Zoom sessions where business logic took shape visually, not in code silos.

Decoupling reigns supreme in FIRE, with front-end and back-end so loosely coupled that, astonishingly, they integrated only post-launch. The back-end demands observations in any order, indifferent to UI whims, while attributes defined via Malli ensure consistent validation and sensitivity across events. Security is ironclad: every payload undergoes envelope encryption in database and streams, treating all data as sacred. Immutability extends to code—nodes locked in namespaces post-deployment—allowing multiple graph versions to coexist for A/B tests or experiments, free from regressions. Local development thrives on pluggable Integrant modules, swapping PostgreSQL for in-memory atoms, fueling 80% offline work and generative tests that exhaust scenarios without internet.

The payoff? A production debut with zero major incidents, rapid bug hunts—like a 10-minute frontend glitch fix via Hydrant—and projections feeding Snowflake for analytics. As Splash modernizes legacy products, FIRE proves that in fintech's volatile arena, thoughtful design yields not just speed but resilience. Callahan's vision underscores a broader truth: in an era of technical entropy, architectures like this don't just solve problems—they illuminate paths to sustainable innovation, where graphs of pure logic tame the chaos of real-world risk.