Automating Business-as-Usual: An AI-Assisted Settlement Platform for a Global EdTech Group

The client

Our client is a global EdTech and student-recruitment group that connects students with university partners and gets paid on the enrolments it drives. That payment is governed by settlement: every admissions cycle, the group reconciles its own student records against each partner's, applies the commercial terms in each contract, and works out exactly who is owed what. Get it wrong and you either leave money on the table or invoice a partner incorrectly. Neither is survivable at scale.

The problem: a critical financial process run entirely by hand

Settlement was business-as-usual work, and it was fully manual, owned end to end by the Data Analytics (DA) team:

Matching was done in Excel and ad-hoc Python. Each cycle, a student data file was reconciled against the CRM by hand, partner by partner.

Checks and exception lists lived in a SQL client. Communication checks and exception handling were applied manually in MySQL Workbench, and cross-check files were assembled by hand.

There was no audit trail. Decisions and the reasoning behind them were lost between cycles. Every settlement started cold, with no record of why the last one resolved the way it did.

One team was the bottleneck. All investigation and correction work fell on the DA team, stretching settlement cycles and pulling skilled analysts away from analysis to do reconciliation by hand.

This is the classic shape of high-value BAU: a process too important to get wrong, too bespoke for an off-the-shelf tool, and quietly consuming the most capable people in the building.

Our approach: a forward-deployed engineer who learned the job first

We did not start by writing code. We started by shadowing the people who did the work.

We embedded a forward-deployed engineer directly with the DA team, sitting with the analysts as they ran a real settlement, watching where the spreadsheets came from, which judgement calls were made by eye, where the exceptions hid, and which steps were genuinely hard versus merely tedious. The settlement logic was never written down in one place; it lived in the analysts' heads and their muscle memory. Shadowing was how we got it out.

That is the difference between automating a process and automating a diagram of a process. By the time we built anything, the engineer understood settlement the way the analysts did, including the edge cases that never make it into a requirements document.

What we built: an AI-assisted settlement platform

We replaced the manual workflow with a single platform that runs the entire settlement, partner by partner, from raw files to finalised, exportable numbers.

AI auto-matching on top of a settlement rules engine

At the core is a standardised matching engine that reconciles student records across every partner with one consistent set of rules instead of a different spreadsheet per analyst. On top of that deterministic engine we layered AI where the rules alone fall short, most visibly in matching: the platform suggests column mappings for each new partner's file automatically, and AI raises the share of records that resolve without a human, targeting an automated match rate of 85%+. The rules engine guarantees consistency; the AI absorbs the messy, real-world variance that used to need an analyst's eye.

A workflow control panel, not a black box

Settlement is a sequence of stages (parse the files, match, review, reconcile communications, apply exclusions, finalise), and every stage has to be visible and reversible. We built a workflow control panel: a job-level state machine that walks each settlement run through its lifecycle, shows progress at a glance, auto-advances the automated steps, and pauses for a human at exactly the points where judgement is required. Nothing skips ahead; nothing happens off the record.

The commercial agreement, encoded as rules

Every partner contract carves out different students from settlement. We built an exclusion-rules engine that turns those commercial terms into authored, scoped, reviewable rules: preview the effect on a real job, then save them at the partner level so each cycle applies the agreement automatically and identically.

Live integrations into the systems the business already runs on

The platform is wired into the client's real stack, not a copy of it: Salesforce (CRM extraction via API), S3 (partner data files), and MySQL (the communications data the comms-check reconciles against). It ingests from where the data already lives and writes results back as the cross-check and settlement-overview exports the finance side expects.

A self-service UI, and a full audit trail

Crucially, the platform moves ownership of investigation and correction off the DA team and onto the Partner Relationship Managers (PRMs) who actually own the partner relationships. A self-service UI lets PRMs resolve their own exceptions instead of queueing behind data analysts. And every action is logged: who did what, when, and why, giving settlement the complete audit trail and end-to-end traceability it never had before.

The outcome

A manual, spreadsheet-and-SQL process became a standardised platform, the same matching logic, applied consistently across every partner, every cycle.

AI-assisted matching targets 85%+ auto-resolution, collapsing the volume of records that need a human touch.

The bottleneck is gone. Investigation and correction shifted from a single overloaded DA team to self-service PRMs, shortening settlement cycles and freeing analysts to do analysis again.

Settlement is now fully auditable, every decision traceable, every cycle reproducible, where before the reasoning evaporated between runs.

Why this is the model, not just a project

This engagement is a template for how we think automation should work. The high-value, bespoke processes that quietly run a business are rarely documented well enough to hand to a vendor and rarely simple enough for a generic tool. The way through is to put an engineer inside the process first, shadow the people doing it, learn the judgement calls, and only then build. And to combine deterministic automation with AI exactly where each is strongest: a rules engine for the logic that must be consistent, AI for the variance that used to need a human, and a control panel that keeps a person in the loop wherever it matters.

That is what a forward-deployed engineer delivers: not a generic tool dropped over the wall, but BAU automated by someone who learned the job before they automated it.