How I built Finleyy in 30 days — solo

An AI agent trained on the entire FCA Handbook, shipped in a month by one person. Here's the actual workflow — and why a senior engineer with AI runs circles around an agency.

Lloyd Owen

Finleyy is an AI agent with deep, structured knowledge of the entire FCA Handbook — thousands of pages of densely written regulation, cross-referenced across dozens of sourcebooks. It can pull live data from the FCA register, run company due diligence, and answer complex compliance questions grounded in actual regulation.

I built it in 30 days. Solo. Design, frontend, backend, infrastructure, the AI agent itself — all of it.

If you took this brief to an agency, they'd quote you six months and a six-figure budget. They wouldn't be lying — at agency pace, that's roughly what it costs. The interesting question is why agencies move at agency pace in the first place, and why one senior engineer with the right tools doesn't have to.

AI changed the maths. It didn't change the work.

A few years ago, a 30-day timeline for something this complex would have been delusional. Today it's just hard. The reason isn't that I've suddenly become faster — it's that the kind of work that used to eat weeks of my time now takes hours.

I want to be precise about what AI is and isn't doing here. AI is not building Finleyy. I am building Finleyy. AI is the equivalent of having an extremely fast, extremely literal junior engineer who never sleeps and occasionally hallucinates entire functions that look plausible but aren't real. Useful — if you know how to manage them.

What I use AI for, day to day:

  • Scaffolding new components from a description
  • Writing boilerplate around well-known patterns (auth flows, CRUD endpoints, RAG plumbing)
  • Translating designs into markup faster than I can type them
  • Generating type definitions from upstream APIs
  • Drafting the first cut of complex queries I'll then refine

What I do not use AI for:

  • Architectural decisions
  • Anything security-sensitive — especially auth, especially in code that touches regulated data
  • Domain logic, where being subtly wrong means shipping incorrect compliance guidance to a regulated firm
  • Reviewing its own work

Small blocks. Human review. Always.

The trick to using AI without producing slop is to keep the loop tight. I don't ask it to build a feature. I ask it to write a function. I read the function. I refactor the function. Then I ask for the next one.

If you let AI run for an hour unsupervised, you come back to a codebase that looks reasonable on the surface but contains five subtly different ways to do the same thing, three abstractions that should never have existed, and at least one function that confidently calls an API method that was deprecated in 2019.

Working in 5–10 minute increments — small block, review, accept or reject, next block — keeps me in control. AI is faster than my fingers but slower than my judgment. Letting my judgment lead the AI's speed, instead of the other way round, is the entire game.

What this looked like on Finleyy

Concretely:

  • The RAG pipeline that grounds answers in the FCA Handbook — I designed it. Chunking strategy, embedding model, retrieval thresholds, citation enforcement. AI wrote some of the integration glue.
  • The FCA register integration that pulls live authorisation data — I designed the data model, caching strategy, failure modes. AI helped me draft the first version of the parser.
  • The auth flow — I wrote it myself, end to end. There is no version of this product where I let AI handle authentication on a regulated-industry codebase.
  • The frontend — mostly me typing, AI accelerating. I know exactly what I want each component to look and behave like. I just don't want to spend an hour translating that into JSX.

The result is a codebase I could have written entirely by hand in three months. I wrote it in one. The parts that matter — the architecture, the security model, the domain logic — are exactly as good as if I'd written every line.

Why this is faster than an agency

An agency working on the same brief would, in a typical week, produce roughly:

  • Several internal meetings to align on what's being built
  • A handover from the account manager to the project manager
  • A handover from the project manager to the lead developer
  • A handover from the lead developer to the people actually writing the code
  • A round of code review by someone who wasn't in any of those meetings
  • A round of QA by someone who wasn't in any of the previous five touchpoints
  • Several follow-up meetings to discuss what got lost in translation

By the time an agency has finished its Monday morning standup, I've shipped a feature.

That's not because I'm a better engineer than the people inside an agency. There are excellent engineers inside agencies. It's because there is no Telephone Game between the person you're paying and the person writing the code. There is one person. They are the same person. Every decision is made by the person making the code, in real time, with full context.

Speed has a quality threshold

Move fast and break things is a fine slogan if you're building a social app for sharing memes. It is the wrong slogan for an FCA compliance product, and it's the wrong slogan for most of the things my clients hire me to build.

The reason I can build Finleyy in 30 days isn't that I cut corners. It's that I cut overhead — meetings I don't need, handoffs I don't have, layers of management nobody is paying me for. AI lets me write more code per hour. Working solo lets me ship more decisions per day. Combined, they collapse the timeline without touching the quality.

If you're sitting on an idea you've been quoted six months and £150k for, most of that estimate is overhead. The actual building, in skilled hands with the right tools, is much faster. Get in touch and we'll figure out what your version of 30 days looks like.