I Built a Portfolio Intelligence System for a Family Office.

Family offices have a visibility problem. They sit on complex portfolios — early-stage venture bets, more traditional deals, real estate, and operating companies — and most of them track it all in spreadsheets that nobody updates. Or they pay six figures a year for portfolio monitoring software that their three-person team will never fully adopt.

I built something in between. A portfolio intelligence system for a family office that runs entirely inside Notion, with Claude as the extraction and analytical engine and the Notion API as the data backbone. It cost a fraction of the enterprise alternatives, the team adopted it immediately because they already lived in Notion, and it surfaces insights that were previously buried across inboxes, PDFs, and Excel files nobody opened twice.

Here's how it actually works.

The data problem

Portfolio data doesn't arrive in clean formats. It arrives as PDF quarterly reports from founders. Excel spreadsheets emailed by their accountants. Investor updates buried in Gmail threads. Capital call notices, bank statements, wire confirmations, all in different formats, from different people, with different levels of detail.

The first challenge isn't analysis. It's extraction.

Every source uses a different structure, different terminology, and a different level of granularity. A founder's Q3 update might have revenue buried in a paragraph. Their accountant's spreadsheet might use column headers that only make sense internally. The next company in the portfolio sends a completely different format.

Before you can monitor a portfolio, you have to normalise all of this into a single schema. That's the unsexy work that most portfolio tools either skip or do badly.

The extraction pipeline

I built a pipeline using Claude to extract structured data from unstructured sources. The workflow is straightforward but effective.

PDFs get fed to Claude with extraction prompts tailored to the document type — founder updates, financial statements, valuations. The prompts specify exactly what fields to extract and what format to return them in. Claude handles the variation between document layouts well. A quarterly report from Company A and a completely different format from Company B both get normalised into the same output schema.

Excel files get parsed programmatically first, pulling out the relevant sheets and ranges, then Claude handles the interpretation layer. What does this column actually mean? Is this number a committed amount or a drawn amount? That contextual interpretation is where the model earns its keep.

Email content gets processed similarly. Founder updates, wire confirmations, capital call notices — Claude extracts the relevant data points and maps them to the portfolio schema.

Everything gets pushed to Notion databases via the API. Each portfolio company has its own row in a dedicated database with standardised fields. I had custom scripts set up so all I had to do was drop the source files into a dedicated folder, run the script, and the whole pipeline would execute — extract, normalise, push to Notion. There's a human review step before anything goes live, but the heavy lifting is automated.

What lives in Notion

The Notion workspace became the single source of truth. The structure includes a master portfolio database with every position, linked to individual rows for each company. Each entry carries standardised KPIs — IRR, multiple, commitment vs drawn, current NAV, last valuation date. Rollup fields aggregate the numbers at the portfolio level.

A tiered KPI framework flags positions based on performance thresholds. Green, amber, red — simple enough for a Monday morning review, detailed enough to drill into when something looks off.

A funding recommendation layer tracks which companies are likely to need follow-on capital, based on burn rate, runway, and the data extracted from founder updates.

Filters and views built on top of all of this, by asset class, by vintage year, by performance tier, by capital call status. The principal could open one Notion page and see the entire portfolio's health in thirty seconds, then drill into any position that needed attention.

Why Notion and not a proper tool

Three reasons. First, the team already used Notion for everything else — deal flow, meeting notes, task management. Adoption was instant because there was nothing new to learn. The best internal tool is the one nobody has to be trained on.

Second, flexibility. Family office portfolios are weird. They hold things that don't fit neatly into the categories enterprise software expects. A Notion database with custom properties can model anything. When a new deal type showed up that didn't fit the original schema, I added a property and a view in 2 minutes.

Third, cost. Enterprise portfolio monitoring tools are priced for institutions with dedicated ops teams. A small family office doesn't need, and can't justify, that overhead.

What I'd build next

The system works. But there are obvious enhancements I never got around to building, and if I were productising this, or rebuilding it for another client, here's where I'd go.

Email-triggered ingestion. Right now the workflow starts when I drop files into a folder and run a script. The next version would hook into the Gmail API, detect incoming portfolio data, founder updates, accountant spreadsheets, capital call notices, and kick off the extraction pipeline automatically. No manual step. I never did this because the honest version of most automation stories is that the last mile of convenience gets deprioritised when the current workflow is already fast enough.

Better PDF parsing. Claude handles document extraction well, but there are dedicated tools now for structured PDF extraction that could serve as a pre-processing layer — pulling tables and structured data out before Claude interprets the content. That would make the extraction more reliable on particularly messy documents.

A lightweight frontend. The whole system runs through Notion and the terminal. I'm comfortable in the terminal, so I never built a proper UI. But for a client who isn't, a simple dashboard, even just a React app pulling from the Notion API, would make the system more accessible.

Automated analytical summaries. The current system extracts and displays data. The next version would use Claude to generate portfolio-level insights automatically — concentration risk flags, benchmark comparisons, narrative summaries of quarterly changes.

The product lesson

The most valuable thing I built here wasn't the technology. It was the normalisation layer. Taking messy, inconsistent data from a dozen different founders and their accountants, and turning it into something a decision-maker can scan in thirty seconds.

The tools are almost secondary. Claude handles extraction. The Notion API handles storage. Notion's native features handle display. The actual product work was designing the schema, defining the KPI tiers, and building a workflow that a small team would actually use every week without being nagged.

Most portfolio visibility problems aren't technology problems. They're data discipline problems. The AI just makes the discipline cheaper to enforce.