Built in a day: an auditable, no-code pipeline for fund data

 

Two things are usually true of data work in fund administration: it is slow to build, and it is slow to trust.

Standing up a new pipeline can take weeks of engineering, and once it exists, teams often spend months hardening it before anyone is comfortable letting it near real fund data.

We wanted to test whether that has to be the case.
Working with Palmer, a private capital administrator, we set out to build a pipeline that was production-grade from the very first run: fully audited, fault-tolerant, and safe to point an AI assistant at.

It took less than a day.

 
 
 

It has to be right…

Fund data is unforgiving. It has to reconcile, it has to be traceable, and it has to be right: a single wrong figure in the wrong place is not a bug, it is a client problem. That is why most teams treat automation cautiously. The faster you appear to move, the more corners you are assumed to be cutting.

The brief for this proof of concept was to prove the opposite. Could we combine the speed of modern, no-code tooling with the governance a regulated environment demands (auditing, fault tolerance, and full data lineage) and still deliver something that worked end to end in a single day?

 

What we built

The result is a no-code pipeline that joins three things teams usually keep in separate silos:

  • Client-side Alteryx automation that prepares, cleans, and validates the data before anything else happens.

  • A routine that runs against Palmer's fund data, held in their Snowflake data warehouse.

  • The results consumed straight back in the client's own environment, ready to use.

Crucially, it does not run as a fragile, hand-rolled script. It runs on an orchestration layer, which is what turns a clever one-off into something you can actually depend on.

 

Orchestrated, not scripted

Every step sits inside an orchestrated workflow with real controls:

  • Triggers for how it starts: manually on demand, on a schedule such as a daily run, or fired automatically by an event when upstream data lands.

  • Branching for what happens next: explicit paths for success and for failure, so the pipeline always knows what to do when a step does not go to plan.

  • Automatic retries and fault tolerance, so a transient wobble upstream does not bring the whole run down.

Nothing in it is a black box. The entire run carries full auditing and lineage tracing, so you can see exactly what ran, in what order, on which data, and with what result. When a regulator, an auditor, or a cautious accountant asks where a number came from, the answer is already recorded.

 
 

The architecture

The pattern has three layers, and keeping them separate is what makes it safe.

 
 
 

Generative tools sit on the edges.
On the way in, they handle the messy human stuff: transcription, loose requirements, working out a schema.
On the way out, they handle chat, insights, and explanation.

They are flexible and forgiving, which is exactly what you want for language and exactly what you do not want for a ledger.

A deterministic engine sits in the middle.
This is where the work that has to be right every time actually happens: Alteryx for the calculations and transformations, an orchestration layer for the flow.
Same inputs, same outputs, every single time, with a full audit trail behind each run.

MCP is the connective tissue. It exposes those deterministic engines as standard tools, so any assistant, and any teammate, can call them the same way they would call anything else. The generative layers never touch the data logic. They simply ask the engine to run it.

 

Why it came together so fast

A one-day build is only possible when there is nothing old to fight. Palmer's platform is modern and API-first by design: secure, authenticated REST endpoints built for private markets, secure data-warehouse sharing from Snowflake, and purpose-built data marts, all wrapped in serious governance: encryption in transit and at rest, single sign-on, and least-privilege access as standard.

Because that foundation was already clean and well-governed, we could spend the day connecting and orchestrating rather than untangling. A modern stack did much of the work before we started.

 
“Every software and technology decision has been carefully made to ensure that we deliver security, controlled data, assurance, reporting and analytics.”
— Phil Godley, Chief Technology Officer, Palmer
 

Fast - and auditable

Because the pipeline is orchestrated and governed rather than scripted, it was reliable from the first run, not after weeks of hardening. It audits itself end to end, it recovers from failures on its own, and it lets a non-technical user interrogate fund data simply by asking.

It helped that Palmer runs a modern, clean data stack, but the speed came mostly from the pattern, and none of it is bespoke to this one case. The same building blocks, Alteryx for the numbers, an orchestration layer for the flow, and MCP for access, apply to any fund-data workflow a team wants to automate safely: capital calls, distributions, investor reporting, regulatory filings, and migrations.

Speed and governance are usually assumed to pull in opposite directions. This proof of concept suggests they need not.

With the right pattern, "fast" and "auditable" can be the same build.

 

Curious what this would look like on your own fund data? Get in touch — we built this one in a day.

 

 
 
Next
Next

From Prompt to Alteryx Workflow in Minutes