Architecture

Overview

The Reeve platform is built on an event-driven architecture designed for asynchronous, decoupled communication between components. This design pattern enables high flexibility, scalability, and resilience by allowing modules to operate independently and communicate through well-defined events rather than direct dependencies.

The architecture promotes a loosely-coupled system where components don’t need to know about each other’s internal implementation details, allowing for easier maintenance, testing, and evolution of the system.

Communication Architecture

Event-Driven Design

At the heart of Reeve’s architecture is the event-driven communication model. The system propagates events through Spring Events , a lightweight, in-process event mechanism that enables different modules to react to state changes and business events without tight coupling.

Basic Communication Flow:

Key aspects of this approach:

Asynchronous Processing: Events are processed asynchronously, allowing long-running operations to complete without blocking other components
Decoupled Components: Publishers and subscribers are independent; modules don’t need to be aware of each other
Extensible Integration: Events can be bridged to external message brokers (Kafka, RabbitMQ) for distributed deployments

Detailed API specifications and message formats for each module are documented in the respective module sections of this documentation.

Flexible Module Configuration

All components can be selectively activated through environment variables, providing fine-grained control over which modules are loaded at runtime. This enables:

Running multiple instances of the Reeve Application with different module configurations
Reducing memory and resource footprint by loading only needed components
Testing and development workflows with minimal dependencies

Software Stack

Reeve is built with modern, enterprise-grade technologies:

Language & Framework: Java with Spring Boot
Build System: Gradle
Containerization: Docker
Identity & Access Management: Keycloak
Event System: Spring Events (with extensibility to external brokers)

This stack provides a solid foundation for building secure, scalable, and maintainable financial applications.

Modular Architecture & Replaceability

One of Reeve’s core architectural principles is modularity with replaceability. Each module (ERP Adapter, Blockchain Publisher, Accounting Core, etc.) is designed to be independent and swappable.

Why Replaceability Matters

Since organisations operate diverse ERP systems and publishing standards, the ability to replace components is essential:

ERP Adapter: Different organisations use different ERP systems (NetSuite, SAP, Oracle, etc.). The ERP Adapter abstraction allows custom implementations for each ERP type without modifying the core platform
Blockchain Publisher: Future requirements may involve different blockchains or publishing protocols. The modular design enables support for multiple blockchain networks
Custom Business Logic: Organisations can implement custom versions of any module to enforce specific business rules or compliance requirements

The loose coupling through events makes this possible—components communicate through well-defined events rather than direct function calls, allowing any module to be replaced with an alternative implementation that conforms to the same event contract.

Deployment Architectures

Local/Standalone Deployment

For development and smaller deployments, all components run within a single application instance, using Spring Events for internal communication.


┌─────────────────────────────────────┐
│    Reeve Application Instance       │
│  ┌──────────────────────────────┐   │
│  │  ERP Adapter                 │   │
│  │  Accounting Core             │   │
│  │  Reporting                   │   │
│  │  Blockchain Publisher        │   │
│  │  Organisation                │   │
│  │        ↓ (Spring Events)     │   │
│  └──────────────────────────────┘   │
└─────────────────────────────────────┘

Distributed Deployment with Message Broker

For production environments requiring enhanced security and scalability, critical components can be isolated into separate network zones with asynchronous communication via message brokers.

Recommended Architecture for AWS:

This architecture provides:

Network Isolation: Sensitive components (ERP Adapter, Blockchain Publisher) operate in isolated security zones
Asynchronous Communication: Message brokers (RabbitMQ, Kafka) facilitate decoupled inter-component communication
Scalability: Components can scale independently based on load
Resilience: Message persistence ensures no data loss during component failures
Audit Trail: Message broker logs provide comprehensive system visibility

Event-to-Broker Mapping

The Spring Events system seamlessly maps to external message brokers, enabling distributed deployments. An example implementation showing the mapping from Spring Events to Kafka (and vice versa) is available in the Reeve Application repository .

Local Development Example

To understand how the distributed architecture works locally, refer to the Docker Compose configuration , which demonstrates all components running in containers with proper message broker integration.

Security Best Practices

The Reeve architecture supports several security measures:

Network Segmentation: Critical components (ERP Adapter, Blockchain Publisher) can be deployed in isolated network zones
Message Broker Security: Encryption, authentication, and authorization at the message broker level
Environment-Based Configuration: Sensitive credentials are managed through environment variables rather than hardcoded values
Identity Management: Keycloak provides centralized authentication and authorization
Audit Logging: Comprehensive event logging enables security monitoring and compliance auditing

Summary

Reeve’s architecture represents a modern approach to financial software design, combining:

Event-driven communication for loose coupling and flexibility
Modular design enabling component replacement without system disruption
Environment-based configuration for adaptability to different deployment scenarios
Production-ready infrastructure supporting both local and distributed deployments
Security-first design with network isolation and comprehensive audit capabilities

This foundation enables organisations to deploy, customize, and evolve Reeve to meet their specific financial management needs while maintaining system integrity and compliance requirements.