Work · Professional · 15

Fintech Real Estate Intelligence System

A monolith rebuilt into event-driven services for 500+ concurrent users, with financial-grade reliability.

Private or proprietary. No public source link.

500+Concurrent users
40%Tech debt reduced
15h+Analyst hours saved weekly
25%Query latency down
Type
Professional
When
MicroIntech · Oct 2024 – Dec 2025
Role
Data Engineer to Lead Developer · architecture, pipelines, LLM services, code review, mentoring five engineers.
Scale
500+ concurrent users · 100% transaction integrity · 18 months

In plain language

For eighteen months I worked on a US fintech platform that told real-estate investors what their money was doing. It started as one large program that did everything, which meant a report could take hours and every new feature made the next one harder. I broke it into separate services that talk to each other, rebuilt the data pipelines so they process events as they arrive rather than in overnight batches, and wrapped language models around the audit work that analysts were doing by hand. I joined as a data engineer and left as lead developer.

The question

A monolith serving financial data had reporting measured in hours and technical debt compounding faster than features shipped. How do you replace the engine without stopping the car, when the records are money and the acceptable error rate is zero?

Eighteen months at a US fintech, moving from Data Engineer to Lead Developer. This is the work the rest of the portfolio is built on.

What it was

A legacy monolithic financial platform serving real estate intelligence. Reporting took hours. Tech debt was compounding faster than features shipped.

What changed

Architecture. Migrated to API-agnostic microservices, cutting BI reporting time by half and accumulated tech debt by 40%.

Pipelines. Event-driven Python pipelines serving 500+ concurrent users at 100% data integrity: zero missed financial transactions, which is the only acceptable number when the records are money.

LLM orchestration. RESTful services wrapping GPT-4 and Llama for automated financial audit, collapsing a 15-hour weekly manual review to roughly three. The reliability work here was mostly about knowing when not to trust the model output and routing those cases to a human.

Infrastructure. Firestore optimisation for high-frequency transaction monitoring cut query latency 25%.

People. Introduced systematic code review and mentored a team of five. Production bug rate fell 15% over six months.

What I took away

The 40% tech debt figure is the one I am proudest of and the one hardest to defend, because tech debt is not directly measurable. It came from a tracked backlog of known-bad modules with agreed remediation criteria, which is to say, we defined the metric before we improved it, so the number means something.

There is no repository for this one. It is proprietary.

How it is put together

Left to right, the path a request or a record takes through the system.

  1. 01

    Ingest

    • Transaction events
    • Property and market feeds
    • Python pipelines

    Event-driven, not overnight batch.

  2. 02

    Services

    • Microservices split from the monolith
    • RESTful interfaces
    • Independent deploys

    API-agnostic boundaries so consumers do not couple to one transport.

  3. 03

    Store

    • Firestore, tuned for high-frequency reads
    • Transaction records at full integrity
  4. 04

    Intelligence

    • LangChain orchestration
    • GPT-4 and Llama 2/3
    • Confidence routing to a human

    The model is a suggestion engine, not an authority.

  5. 05

    Consume

    • BI reporting
    • Analyst audit queue
    • 500+ concurrent users
The migration target, not the starting point. The monolith is on the left of every one of these lanes historically; what changed is that each concern got its own service boundary and its own failure mode.

What happens, step by step

In plain language, in the order it happens.

  1. Find the seams

    Before splitting anything, identify which parts of the monolith actually have independent reasons to change. A split along the wrong seam produces a distributed monolith, which is strictly worse than the thing you started with.

  2. Move to event-driven ingestion

    Transactions arrive as events and are processed as they land, rather than being swept up in an overnight batch. This is what took reporting from hours to something usable during a working day.

  3. Hold integrity at 100%

    Zero missed financial transactions is the only acceptable number when the records are money. That constraint drove the pipeline design more than throughput did.

  4. Wrap the audit in language models

    RESTful services around GPT-4 and Llama for automated financial audit, collapsing roughly fifteen hours of weekly manual review to about three.

  5. Route what the model should not decide

    The reliability work was mostly about knowing when not to trust the output. Low-confidence cases go to a human rather than being resolved by the model, which is the difference between a useful audit tool and an expensive liability.

  6. Make the improvement measurable

    Technical debt was tracked as a named backlog of known-bad modules with agreed remediation criteria, defined before the work started, so the 40% reduction refers to something specific rather than a feeling.

Decisions, and what they cost

Every choice worth recording has a road not taken. Both are here.

  • API-agnostic microservices

    instead ofContinuing to extend the monolith

    Debt was compounding faster than features shipped. The monolith was not slow to run so much as slow to change. Independent service boundaries let deploys stop being coordinated events. The cost is real: distributed tracing, more failure modes, and a network call where a function call used to be.

  • Event-driven pipelines

    instead ofScheduled batch

    Batch reporting means the answer is always as old as the last run. For an investor watching a position, that lag is the product defect. Events cost more in operational complexity and buy currency.

  • Confidence routing to a human

    instead ofTrusting model output end to end

    In financial audit, a confidently wrong answer is worse than no answer. Knowing when not to trust the model is the actual engineering; the orchestration around it is comparatively easy.

  • Define the tech-debt metric before improving it

    instead ofClaiming a reduction afterwards

    Technical debt is not directly measurable, so a percentage quoted after the fact is unfalsifiable. Agreeing a tracked backlog and remediation criteria up front is the only reason the 40% figure means anything, and it is the number I am proudest of and the hardest to defend.

What came out of it

  • BI reporting time halved; tracked technical debt down 40% against pre-agreed criteria.
  • Event-driven pipelines serving 500+ concurrent users at 100% data integrity: zero missed financial transactions.
  • Analyst audit collapsed from roughly fifteen hours a week to about three.
  • Firestore optimisation cut query latency 25% for high-frequency transaction monitoring.
  • Systematic code review introduced and five engineers mentored; production bug rate down 15% over six months.

Still open

  • Proprietary: there is no repository and there never will be. This page is the artefact.
  • The LLM audit layer was built before the current generation of models. Much of the confidence routing would be simpler now.

Built with

  • Python
  • LangChain
  • GPT-4
  • Llama 2/3
  • Firebase
  • REST APIs
  • Microservices