From a Framer Landing Page to an AI-Native Open Finance Platform: 10 Months at Finerty

Ten months ago, Finerty consisted of a marketing website built on Framer and an incomplete Figma journey for something called a “Letter of Authority”. Today, it’s an Open Finance platform for financial brokerages — roughly thirty microservices running on Azure Kubernetes, with agentic AI woven through both the advisor and client journeys — and we’re in the final stretch of ISO 27001:2022 certification.

This is the story of how we got there, and what I learned building a regulated, AI-native fintech platform at startup speed.

The Starting Point: One Boring, Painful Document

A Letter of Authority is the document a client signs to let a financial advisor talk to their pension or insurance provider on their behalf. It’s mundane, it’s paper-based, and it’s the bottleneck at the start of every advisory relationship in Ireland.

That was the wedge. The first commit landed on 3 October 2025: a multi-tenant platform where brokerages could onboard advisors, advisors could onboard clients, and clients could digitally sign LOAs that went straight to providers. Three React portals (admin, advisor, client), each behind its own backend-for-frontend gateway, a central Spring Boot resource server, and Keycloak with two isolated identity realms per brokerage — one for advisors, one for clients with passwordless OTP login.

That architecture decision — strict tenant isolation from day one, at the identity layer and in every database query — turned out to be the single best call we made. Everything we built afterwards inherited it for free. Including, crucially, the AI.

The Platform: From Signing Documents to Understanding Clients

Once advisors could get authority over policies digitally, the obvious next question was: what else does an advisor need to actually advise? The answer kept expanding, and so did the platform:

Change of Agency workflows, provider portals, and open-access pages so providers could respond without an account.
Open Banking integration, so a client’s real accounts and transactions flow into the platform — and auto-fill their fact-find.
A living fact-find: a 12-section wizard whose answers project into a normalized financial-position layer — accounts, assets, policies, income and expenditure — rather than dying in a PDF.
A fund centre aggregating ~2,500 funds from 9 Irish providers on a 12-hour refresh cycle, with per-brokerage fund universes and multi-fund strategies.
A quotes engine driven by provider rate cards, and proposals with generated Statements of Suitability that clients e-sign.
Cashflow modelling with a full Irish tax engine — PAYE, USC, PRSI, CGT, CAT, exit tax, pension event taxes — projecting a household’s finances decades forward, with what-if scenarios.

None of this was in the original Figma file. But the biggest departure from that Figma file deserves its own chapter.

The Biggest Shift: Agentic AI in Both Journeys

Somewhere along the way, the platform stopped merely storing client data and started reasoning over it. We built an intelligence service — the home of “Fin”, our AI layer — and rebuilt the core advisor and client journeys around it.

The client journey became conversational. Onboarding is no longer just forms. Clients can complete their fact-find through a guided chatbot, and the Deep Dive — an AI-led onboarding interview — adapts its questions to what the client has already told us: it reads the completed fact-find, risk assessment and sustainability preferences, skips what it already knows, and digs into what it doesn’t. Voice-enabled, brokerage-brandable, and every answer validated server-side against a schema the AI cannot bend.

The advisor journey became augmented. Advisors get an AI companion grounded in the client’s actual data — “what’s their risk profile?”, “what’s their net worth?”, “summarise this relationship” — plus:

Executive summaries that regenerate themselves, event-driven, whenever a client’s fact-find or risk data changes.
Suggested next steps produced by a two-agent pipeline: one model drafts what-if financial plans, a second Financial Advice Agent reviews and vets them before an advisor ever sees them. One click turns an accepted suggestion into a real cashflow scenario.
A cashflow copilot that builds and edits what-if forecasts conversationally.
AI-drafted Statements of Suitability, section by section, with the advisor always editing and owning the final document.

And the agentic part is governed, not vibes. This is regulated financial services, so the architecture is deliberately paranoid:

The LLM never touches the database. It can only call registered, schema-validated tools that proxy to the same tenant-scoped, permission-enforced APIs a human user hits. The user’s own identity travels with every tool call.
Writes use a propose-and-confirm pattern: the agent proposes creating a note, a client, a policy — a human confirms — and both steps land in the audit trail.
Server-owned figures (quote numbers, cashflow projections, risk scores) are computed by deterministic engines and cannot be written by the model. The AI narrates; the engines calculate.
Every session, tool call and generation is metered, rate-limited, budgeted per brokerage, and audited.

That last section is, I think, the actual product insight of the ten months: in wealth management, the hard part of AI isn’t the model — it’s the data and the harness. Grounding, authorization, auditability, and knowing exactly which numbers the model is allowed to produce.

The Numbers

For the ten months from first commit to today: 4,980 commits across 788 merged pull requests; ~1 million lines of Java, TypeScript, Python and SQL; ~30 deployable services; 283 database migrations on the core service alone; ~2,000 test files plus 62 end-to-end suites; 394 documentation files; 19 CI/CD pipelines with infrastructure fully in Terraform. We also migrated the entire runtime from Docker Compose on VMs to Azure Kubernetes Service — 28 services on Kustomize overlays, one-click deploys to test, reviewer-gated deploys to production.

Security Wasn’t a Phase — It Was the Operating System

The instinct at startup speed is to defer compliance. We did the opposite, and I think it’s why the ISO 27001 process has been an exercise in documenting what we do rather than changing what we do. Every service publishes audit events to an immutable, PII-encrypted store. Secrets live in a vault, envelope-encrypted where they touch the database. Static analysis and secret scanning gate every merge. Tenant isolation is enforced in code, at the identity provider, and in review. When the auditors arrived, 115 of 120 automated compliance checks were already green.

The lesson: in fintech, security debt compounds faster than tech debt. Pay it up front.

What I Learned

People always come first — advisors, clients and company employees. Enable them and always strive to understand their needs and objectives. Whether you are building an AI companion or an automated process, understanding who it serves and what they’re trying to achieve is what separates a feature people use from a feature people tolerate.
In regulated finance, the hard part of AI isn’t the model — it’s the data and the harness. Grounding, authorization, auditability. Get the guardrails right and you ship AI faster because of them, not despite them.
Multi-tenancy is a day-one decision. Retrofitting isolation is a rewrite; inheriting it is free — and our AI layer inherited it too.
Agentic AI in regulated industries means separation of powers. The model proposes; deterministic engines calculate; humans confirm; the audit trail records.
Documentation is a force multiplier at speed. 394 docs sounds like bureaucracy; it’s actually how a small team ships 788 PRs without stepping on each other — and how AI tooling stays useful.
A boring wedge beats a grand vision. The Letter of Authority was the least glamorous document in financial services. It was also the door to everything else.

Ten months. One landing page to an AI-native Open Finance platform. I can’t wait to see what the next ten look like.