Building an Enterprise Blockchain Platform: Over Half a Million Lines of Code

I ran git log across our entire codebase the other day. Not to prove anything, I was genuinely curious. When you're heads-down building every day, you lose track of how much ground you've actually covered. The numbers surprised me.

3,678 commits. Over half a million lines of source code. Seven repositories. One platform.

That number still catches me off guard. Over 529,000 lines of actual, hand-authored source code, TypeScript, Go, Prisma schemas, CSS, YAML manifests, written across backend microservices, blockchain smart contracts, two frontend applications, infrastructure configs, and a marketing site. All from scratch. If you count everything that's been committed, database schemas, configuration files, dependency manifests, infrastructure specs, the total git insertions cross 4.3 million lines. But the number I care about is the source code I actually wrote.

The Breakdown

Here's how it shakes out across the platform's ecosystem:

A few things stand out.

The Backend Tells a Story

1,448 commits and over 270,000 lines of TypeScript in the backend alone. That's where the bulk of the platform lives.

The backend is 12+ microservices following clean architecture, authentication, KYC processing, tokenomics, government treasury, wallet operations, and more. Each one with its own domain layer, use cases, repository ports, and infrastructure implementations. When you commit to clean architecture at that scale, every service multiplies the surface area. Domain entities, value objects, DTOs, controllers, guards, repository interfaces, repository implementations, the line count adds up fast, and it's all intentional structure.

Chaincode Doesn't Forgive

717 commits and over 62,000 lines of Go in the smart contracts repository. Smart contracts on Hyperledger Fabric demand a different discipline. You can't just push a quick fix, every function must be deterministic, every state change must be atomic, every access control check must be airtight.

When you're writing code that directly handles financial operations on a blockchain, you measure twice and cut once. Every line earns its place because the cost of getting it wrong is high.

Frontends Move Fast

The wallet frontend (701 commits, 105K lines) and admin frontend (310 commits, 56K lines) tell a different story. Frontends are where user feedback hits directly. Features get built, tested with real users, adjusted, rebuilt. The wallet app alone handles everything from onboarding flows to KYC document uploads to transaction histories, each one its own miniature product.

Infrastructure is Quiet but Critical

76 commits. 11,460 lines of YAML and shell scripts.

The infrastructure repository is the Kubernetes manifests, deployment configurations, and infrastructure-as-code that keeps everything running across multiple VPS instances. The commit count is modest compared to the rest, but that doesn't mean low importance. It means you get it right because you have to. A bad deployment manifest doesn't give you a graceful error message, it gives you downtime.

How This Got Built: A Multi-Agent Architecture on Claude Code

Here's the part that might raise eyebrows: this entire platform, over half a million lines of source code across backend, blockchain, frontends, and infrastructure, was built using a multi-agent orchestration system I designed on top of Claude Code.

Not "vibe coding." Not prompting an AI and hoping for the best. I'm talking about a structured, hierarchical agent architecture modelled after how real engineering teams operate.

The system works in tiers. At the top sits an orchestrator that coordinates everything. Below that, an Architect agent (running on Opus) handles system design and API decisions. A Researcher agent (on Haiku, for speed) explores the codebase to find existing patterns before anyone writes new code. A Security agent (Opus) audits for vulnerabilities.

Below them, an implementation tier: specialized agents for backend, frontend, chaincode, and infrastructure, each scoped to their domain, each following the project's conventions because those conventions are baked into their agent definitions. And below that, a validation tier: testers, reviewers, debuggers that catch issues before they ship.

The critical innovation was a prompt-writer agent, a lightweight Haiku agent that generates context-optimized prompts for other agents. Instead of dumping a vague task into a sub-agent, the prompt-writer reads the relevant files, pulls in the right conventions, and structures the task with clear acceptance criteria. The difference in output quality is night and day.

This isn't about replacing engineering judgment. Every architectural decision, every module design, every deployment strategy, that's still me. The multi-agent system handles the execution at scale. It's the difference between conducting an orchestra and playing every instrument yourself.

I wrote about the architecture in detail in a separate post, the failures, the iterations, and what I learned about making AI agents actually work together on enterprise-grade code.

The point is: over half a million lines of production source code didn't happen despite using AI. It happened because of a deliberate system designed to make AI work at enterprise scale. Clean architecture across 12 microservices. Deterministic smart contracts on Hyperledger Fabric. Two production frontends. Kubernetes infrastructure across multiple environments. All of it coordinated through an agent hierarchy that treats AI as a structured engineering capability, not a magic autocomplete.

What the Numbers Don't Show

Git stats are a blunt instrument. They don't capture:

They also don't distinguish between a throwaway script and a carefully crafted domain entity that enforces business invariants. A hundred lines of well-designed code can be worth more than ten thousand lines of the alternative.

What I've Learned

Building a full platform, backend services, blockchain smart contracts, two frontend applications, infrastructure, teaches you things that working on a single slice never would.

Everything is connected. A schema change in the backend ripples into the chaincode, the admin panel, and the wallet app. You learn to think in systems, not components.

Iteration is the process. Not every line written survives. Refactoring, extracting services, evolving architecture, that's how you get from a working prototype to a production platform. The lines that matter are the ones standing today, built on the lessons of everything that came before.

Consistency compounds. 3,678 commits didn't happen in a sprint. They happened one at a time, day after day. The compounding effect of consistent, incremental progress is genuinely powerful. You don't notice it in the moment, but then you run git log one day and realize what you've built.

And here's the thing, this is still just the MVP. The core infrastructure, the foundational modules, the base architecture. The full functional requirements go far beyond what's been built so far. Governance, lending pools, organization accounts, advanced trust scoring, tax engines, entire modules that are specced out and waiting to be implemented. Half a million lines of source code and we're still laying groundwork.

I'm not done. Not even close. But it's useful to stop occasionally, look at the numbers, and acknowledge the ground covered.

Over half a million lines. Still going.