I build software and
digital experiences that solve real problems.

The Engineering Challenge

Coordinating complex recurring billing schedules between multiple stakeholders requires unwavering transactional consistency. The system needed to manage custom payment plans for both clients and vendors, generate deterministic immutable invoice snapshots, handle fluctuating payment statuses via webhooks, and ensure no transaction is ever charged twice or silently lost during network failures.

Architecture & Approach

Architected a resilient Spring Boot backend utilizing an Event-Driven Architecture with an idempotent transaction engine. Integrated Paystack for checkout initialization and automated verification. Implemented the Transactional Outbox Pattern to guarantee message delivery to the message broker without two-phase commit overhead, coupled with comprehensive audit logging for each invoice lifecycle state.

Architectural Pillars

• State-Machine-Driven Billing Engine: Coordinates draft, pending, paid, overdue, and reconciled states.
• Immutable Invoice Snapshots: Preserves customer, tax, and itemized fee snapshots at invoice generation time.
• Idempotent Paystack Webhook Handler: Prevents duplicate balance updates through unique event hashes and distributed locking.
• Event-Driven Workflows: Dispatches asynchronous events for ledger updates, automated receipt distribution, and payment plan state transitions.

The Engineering Challenge

Developers frequently need consistent, low-latency access to deeply nested regional and administrative boundary data (countries, administrative zones, local municipalities, postal identifiers). Monolithic lookups often cause excessive relational joins, and integrating third-party consumers without standard client libraries leads to inconsistent client-side error handling and authentication misconfigurations.

Architecture & Approach

Engineered a dedicated REST API service in Spring Boot backed by indexed relational storage with path-enumeration hierarchical queries for sub-millisecond retrieval. Built a companion reusable Java SDK packaged with Apache Maven, offering enterprise consumers a type-safe, fluent client with automated retry policies, connection pooling, and built-in API Key / Client ID authentication handling.

Architectural Pillars

• Two-Tier API Authentication: High-speed verification filters validating Client ID and hashed API keys on incoming HTTP headers.
• Hierarchical Path-Enumeration Data Model: Enables instant parent-child tree queries without recursive database penalties.
• Lightweight Fluent Java SDK: Minimal external dependencies, standard Maven distribution, and intuitive method chaining.
• Resilient HTTP Client Architecture: Exponential backoff retries, configurable timeouts, and typed domain exceptions.

The Engineering Challenge

Debugging multi-service production bottlenecks without central log aggregation or standardized latency metrics leads to delayed incident recovery and invisible errors. Backend services required transparent telemetry without incurring CPU overhead or modifying core business logic.

Architecture & Approach

Configured a lightweight containerized observability pipeline using Docker, Prometheus, Grafana, and Grafana Loki. Exposed micrometer metrics from Spring Boot Actuator endpoints, ingested structured JSON logs with correlation IDs, and created actionable operational dashboards for monitoring p95/p99 request latencies, JVM memory pools, database connection pools, and HTTP error rates.

Architectural Pillars

• Prometheus Scraping Engine: Pulls metrics at 15-second intervals from microservice Actuator endpoints.
• Centralized Log Aggregation via Loki: Labels logs with correlation IDs for cross-service request tracing.
• Pre-Configured Grafana Alerting: Triggers operational notifications when error rates exceed 1% or latency spikes above 500ms.
• Cloud Containerization: Dockerfiles with multi-stage builds optimized for Azure Container Apps and Google Cloud Run.