The situation
Picture a multi-tenant platform serving small professional services firms. Every new firm signing up triggers 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 is workflow design, spends roughly a third of the 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 would track one full onboarding end-to-end and break down where the working minutes go. In a case like this, the split typically looks like:
- ~45 minutes retyping the form they sent into the fields our system expects
- ~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 retyping the same facts from one system into another.
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.
- The AI only ever fills in fixed fields. No free-form writing 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 answer has to fit a fixed set of fields, 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
There are three points where the system stops and waits for a person, 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 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 fixed fields 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 going live, including the audit, the field design, the n8n wiring, the approval screens, and a two-week pilot running side-by-side with the existing manual flow.
What we'd carry over to the next project
- Locking the AI to fixed fields pays for itself 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.