The situation
The client was a multi-tenant platform serving small professional services firms. Every new firm signing up triggered a manual onboarding process: collecting paperwork, verifying the entity, configuring the workspace, provisioning users, and sending welcome materials. The operations lead — a senior person whose actual job was workflow design — was spending roughly a third of their week shepherding new accounts through this pipeline.
The pipeline had grown organically over two years. It involved seven SaaS tools, three different email templates, two spreadsheets, and several "the way we do it for THIS kind of client" exceptions that lived only in the operations lead's head. The cycle time was three working days from form submission to "your workspace is ready" email — partly because of the work itself, partly because each step had to wait for the next person in the chain.
Where the time went
During the audit phase we tracked one full onboarding end-to-end and broke down where the working minutes were spent:
- ~45 minutes reformatting the inbound intake into the platform's typed schema
- ~30 minutes verifying the submitted entity details against public records
- ~60 minutes provisioning the workspace, the user accounts, and the integrations
- ~25 minutes drafting and sending the welcome email with personalized links
- ~3 hours of waiting for the operations lead to come back to the next step after their meetings
- The remainder: scattered checking, double-checking, and a handful of judgment calls that genuinely needed a human
The interesting part: only 15–20 minutes of the cumulative working time was real judgment work. Everything else was mechanical translation between systems that didn't talk to each other.
Our approach
We started with three constraints, agreed in writing during scoping:
- Keep the humans where they matter. Entity verification edge cases, exception handling, and the final "ready to ship" approval were all retained for human review.
- Typed schemas everywhere. No free-text outputs from an AI model touching downstream systems. Every step produces a Pydantic object validated before the next step runs.
- Reversible by default. Every action the automation takes is recorded with enough context that a human can roll it back if needed.
Architecture
The system ended up being smaller than people expect when you describe "AI-powered onboarding pipeline." There are four moving parts:
1. A typed intake form
The marketing site posts the form to a small FastAPI service that validates against a Pydantic schema. Anything malformed never reaches downstream — it gets bounced back to the submitter with specific field-level errors.
2. An n8n orchestrator
n8n is the choreographer. It receives the validated intake, runs the entity-verification step against a public registry API, posts the result to a Slack approval channel, and waits. On approval, it kicks off the workspace-provisioning steps in the right order.
3. An LLM step (Anthropic Claude)
The only LLM call in the pipeline is the one that turns the verified intake into the personalized welcome content. The prompt is constrained, the output is parsed against a typed schema, and the result is rendered into the firm's existing email template — Claude does not get to write the email itself, only the personalization slots.
4. The audit log
Every step writes to an append-only audit log in Postgres. We can replay an onboarding end-to-end from the log and produce a printable record for any client.
Where humans stayed in the loop
The system has three explicit approval gates, all on Slack:
- After entity verification — the operations lead sees the registry-match summary and either approves the match or flags a manual-review case.
- Before workspace provisioning — a sanity check on the proposed configuration before any external systems get touched.
- Before the welcome email sends — the operations lead sees the generated personalization content and the rendered email preview, and clicks "Send" or edits first.
The gates are deliberately not "AI confidence above threshold = auto-approve." Even when the model is confident, a human eye on the artifact catches the cases where confidence and correctness diverge.
Tech stack
Deliberately conservative — everything the client's operations lead could understand after a one-hour walkthrough:
- FastAPI + Pydantic for the typed intake endpoint
- n8n (self-hosted) for the workflow orchestration and approval surfaces
- Anthropic Claude via the API for the single LLM step
- PostgreSQL for the audit log and operational state
- Slack as the approval interface — operations lead was already living there
- AWS Lambda + CloudWatch for the small handful of bespoke processing functions
Outcome
- Cycle time dropped from 3 working days to under 5 minutes of active human time per onboarding.
- Error rate on workspace provisioning dropped to zero across the first 60 days — the typed schema caught what the human reviewer used to catch (eventually).
- Auditability went from "ask Sarah" to a replayable log we could print as a PDF on demand.
- Operations lead's recovered time redirected into actual workflow design — which is what we were paid to make possible.
Build time: 4 weeks from Discovery to production cut-over, including the audit, the typed schema design, the n8n choreography, the approval surfaces, and a two-week pilot running side-by-side with the existing manual flow.
What we'd carry over to the next engagement
- Typed schemas pay for themselves in week two. Every onboarding-style automation we ship now starts with the schema.
- Slack as approval UI > building a custom approval UI for almost every internal workflow under 100 approvals/day. The operations team already lives there.
- One LLM call is usually enough. Most "AI workflow" projects we see could be one well-prompted call wrapped in deterministic code — not five chained agents.
- The audit log is not optional. Clients ask for it later. Build it first.