• 

  this is the codebase for the project loan lumen

About the project — LoanLumen Inspiration

I built LoanLumen because the secondary loan market is large but painfully opaque. Traders still rely on emails, spreadsheets and BWIC PDFs to discover, price and transfer loan interests — a slow, error-prone process that increases cost, reduces liquidity and creates operational risk.

While researching the space I had an interesting time studying drawdowns in the financial sector, especially in the loan sub-sector. That research was challenging but exciting — it taught me that challenges aren’t only opportunities to learn, they create a new drive for success. Seeing the real costs of opacity (long settlement windows, inconsistent pricing, manual reconciliation) motivated the product idea: make loan trading visible, auditable and faster.

What I built

LoanLumen is a desktop-first trading dashboard that demonstrates a realistic end-to-end flow for syndicated loans:

Document ingestion + NLP: upload a loan agreement PDF and extract canonical fields (maturity, interest, transfer restrictions, borrowers).

Real-time marketplace: searchable listings, live bid ladder (WebSockets), bid expiry and private negotiation chat.

Consent workflow: request borrower consent for transfer-restricted loans and block execution until consent is recorded.

Atomic acceptance + executed trade recording: accept one bid atomically (other bids → rejected) and store an ExecutedTrade.

Immutable audit anchoring: every critical event creates an audit row whose SHA-256 hash is anchored to a ledger simulation (txId stored) so the timeline is tamper-evident.

Price discovery & analytics: price history, simple, explainable fair-value suggestion, and portfolio P&L exports.

Security & production practices: RBAC, token revocation, rate limiting, field encryption stubs, CI, tests and a Dockerized dev stack.

How I built it (high level)

I followed a clean-architecture, sprint-based approach so a single developer could deliver an enterprise-grade proof of concept:

Sprint planning & MVP lock — defined three demo flows: (1) seller lists; (2) buyer bids; (3) accept + audit anchor.

Tech stack

Frontend: React + TypeScript (Vite)

Backend: Node.js + Express + TypeScript, Prisma + PostgreSQL

Real-time: socket.io

NLP PoC: Python Flask stub (swap-in Textract/Bedrock/Comprehend later)

Ledger: demo ledger simulator (HTTP anchor) with LedgerAnchor records

Dev ops: Docker Compose, GitHub Actions, Prisma migrations

Implementation — I built small, well-documented modules (auth, listings, bids, audit, ledger, NLP client) and CI that runs unit tests and E2E checks.

Polish & demo — accessibility checks, Playwright E2E for the main flow, a 3-minute demo script and a pitch slide set.

Key technical idea (fair-value math)

The fair-value suggestion I implemented is intentionally simple and auditable — a weighted average of recent executed trades where weights reflect recency and trade size:

FairValue

  

   ∑ 𝑖 𝑤 𝑖   𝑝 𝑖 ∑ 𝑖 𝑤 𝑖 with 𝑤 𝑖

  

   exp ⁡  ⁣ ( − Δ 𝑡 𝑖 𝑇 ) ⋅ log ⁡ ( 1 + amount 𝑖 ) FairValue= ∑ i ​

w i ​

∑ i ​

w i ​

p i ​

​

withw i ​

=exp(− T Δt i ​

​

)⋅log(1+amount i ​

)

𝑝 𝑖 p i ​

is the executed price of comparable trade 𝑖 i

Δ 𝑡 𝑖 Δt i ​

is the age (days) of trade 𝑖 i and 𝑇 T is the decay timescale (e.g., 30 days) This produces an explainable number (judges can see the comparables), and it’s easy to tune.

What I learned

Domain depth matters. Researching drawdowns and loan-sector dynamics taught me how contractual quirks (transfer restrictions, borrower consent clauses, covenants) drive workflow complexity. That domain insight directly shaped the consent workflow and the parsed metadata model.

NLP is helpful but brittle. Parsing loan agreements requires robust rule fallbacks and an admin override UI — the system must accept that ML is probabilistic and provide a human-in-the-loop.

Security is non-negotiable. Even for a demo, role separation, token revocation, field encryption and proper secret handling are essential to get institutional buy-in.

Simplicity sells. For judges and users, explainable heuristics (not black-box ML) are far more persuasive in early pilots.

Challenges I faced

Heterogeneous documents: facility agreements vary widely; a single parser doesn’t work on all PDFs. Solution: combine simple rule-based extraction, a small ML model, and an override UI.

Consent & legal workflow modelling: simulating borrower consent while keeping the demo realistic required building a demo callback flow that’s clearly labelled as simulation.

Immutable anchoring tradeoffs: full permissioned ledger integration is heavy; for the hackathon I built a ledger simulator and designed the data model to allow a future migration to Hyperledger/Corda or AWS QLDB.

Solo-dev scope management: there were many tempting features. I enforced strict MVP sprints so the demo showed depth (end-to-end flow) rather than breadth.

Impact & what’s next

LoanLumen compresses the three slowest moments in loan trading — discovery, due diligence and settlement confidence — into a single, auditable workflow. Rough demo estimates show the potential to reduce pre-trade review time dramatically. For example, if manual review takes 𝑡

old

6 t old ​

=6 hours and LoanLumen reduces it to 𝑡

new

0.5 t new ​

=0.5 hours, the time reduction is

%

reduction

1 − 𝑡 new 𝑡

old

1 − 0.5 6 ≈ 91.7 % . %reduction=1− t old ​

t new ​

​

=1− 6 0.5 ​

≈91.7%.

Next steps I’d build for a pilot:

Replace the NLP stub with a hardened pipeline (Amazon Textract + Comprehend + Bedrock summarization).

Integrate a permissioned ledger for real anchors (Corda / Hyperledger).

Add richer analytics and single-sign-on for enterprise users.

Conduct a small pilot with two sell-side desks and one buy-side firm.

Final note (personal)

This project was driven by curiosity about drawdowns and structural weaknesses in the loan market. That research was hard but energizing — it converted technical challenges into motivation. Building LoanLumen taught me that shipping thoughtful, secure, and explainable features is the fastest way to turn an idea into something institutions can trust and actually use.

Built With

• actions.
• also
• amazon-bedrock-cloud-&-infrastructure:-docker
• amazon-comprehend
• amazon-textract
• aws-(architecture-ready)-security-&-auth:-jwt-based-authentication
• aws-ai-services-(textract
• bedrock)
• can
• comprehend
• css3-backend:-node.js
• demoed
• docker
• docker-compose
• exactly
• express.js
• express.js-real-time:-socket.io-(websockets)-databases:-postgresql-orm-&-migrations:-prisma-ai-/-nlp-(prototype-&-planned):-python-(flask)
• for
• github
• html5
• i
• if
• it
• javascript
• languages:-typescript
• list
• match
• node.js
• on-screen
• openapi-(swagger)-data-&-audit:-cryptographic-hashing-(sha-256)
• postgresql
• prisma
• python
• role-based-access-control-(rbac)-devops-&-ci/cd:-github-actions-apis-&-standards:-rest-apis
• socket.io
• sql-frontend:-react
• tailor
• tamper-evident-audit-logs-if-you-want-a-shorter-version-(some-devpost-forms-prefer-brevity)
• this
• to
• typescript
• ultra-safe
• use:-built-with:-react
• vite
• want
• what
• you