Sarah
Legal Assistant
“I want to capture everything we need without making the caller wait. No tab-hopping. No 'let me call you back'.”
The File Opening Design Explorer
Every firm opens files. Most stitch it together from three systems, six sticky notes, and the partner's inbox. Here's how we designed it instead — one guided journey from a phone ringing at reception to a live matter in the PMS. Ten scenes. Four people. One elegant product.
Scroll — the story starts below
Meet the people
Every scene in this journey belongs to someone real. These are the four personas we designed for — each with a different job, a different pressure, and a different moment of value.
Legal Assistant
“I want to capture everything we need without making the caller wait. No tab-hopping. No 'let me call you back'.”
Responsible Partner
“Show me the conflict, show me the risk. Give me one screen to decide on, and don't make me log into three systems to find it.”
Compliance Officer
“Every step we take to onboard a client has to leave a complete record. If legal ever asks, I can point to exactly what happened, when, and who decided.”
The Client
“I've been in a car accident. I'd like some advice. Please don't ask me for my address three times.”
The journey — ten scenes
Follow Sarah, David, Rachel and James through a real file opening. Each scene pairs what the user sees with what the system does — and an expandable technical view showing how the product matures across three build passes: Skeleton, Manual, and Automation.
The phone rings at 9:04am. A car accident. A new client.
James calls reception. He was in a car accident last week and he'd like some advice. Sarah needs to open a file without leaving the conversation — no tab-hopping, no tell-me-that-again, no let-me-call-you-back.
She captures the essentials while they talk: name, phone, a rough matter type, a note on urgency. The form feels like a conversation guide rather than a data-entry chore. By the time James hangs up, the enquiry exists.
When the same enquiry arrives at 8:47pm on a Sunday from the firm's website, the system does the legwork so Sarah sees a ready-to-triage enquiry on Monday morning — no one lost the caller.
Sarah clicks “+ New Enquiry”. A bare work item of type alt-fo-shared-process-enquiry is created in Draft. No form — just a title input. This validates the lifecycle shape before the forms arrive.
An ODS-backed triage form opens (alt-fo-shared-form-enquiry-triage). Caller name, phone, instruction types from the option set, notes. On save: ODS Person upserts, links as alt-fo-shared-role-enquiry-contact, intake source stamped phone, enquiry created in Draft.
External intake arrives via POST /api/v1/intake/enquiry with an idempotency key. On phase-entry to Draft, alt-fo-shared-vw-enquiry-ods-upsert runs: matches by email → phone → creates, links the Person as enquiry-contact, stamps intake source. If required fields are missing, spawns a review task rather than erroring — the caller is never lost.
Practice area? Conflict? Two questions that unlock everything else.
The enquiry is in Triage. Sarah needs to figure out two things before anything else can happen: what practice area is this really, and is there a conflict with another firm or an existing client?
If both come back clean, the enquiry moves on. If a conflict appears, a partner reviews. The decision — clear, review, or conflict — is recorded against the search itself, not buried in an email thread.
Sarah types the classification and conflict note into the enquiry description, clicks Submit to Instructions. Validates the phase shape (Draft → Triage → Instructions → Completed) with an off-ramp to Not Proceeding.
Two tasks appear: Classification (practice area + urgency from the option set) and Conflict Check (manual search, outcome recorded on the task). The Client Picker widget links an existing or new Client via a client-related relationship. The Submit to Instructions button unlocks only when both triage tasks complete AND the client is linked — enforced by ChildWorkItemsCompleted and alt-fo-shared-dqr-enquiry-client-linked.
alt-fo-shared-vw-enquiry-triage fires on Triage entry, auto-creating both tasks (parallel fan-out). Sarah still decides the outcomes — the task completion IS the user judgement. A conflict-outcome gateway detects whether partner review is needed and spawns it automatically. “Re-run informational conflict” stays as a ribbon button per CFG-RS-02 — the toolbox pattern.
Turn the enquiry into actual work.
Triage is done. Now the enquiry becomes one or more instructions — a Personal Injury instruction, say, and separately a Workers Compensation one if the same caller is pursuing both. Each instruction is the real thread that will become a matter in the PMS.
The enquiry itself completes, but it stays as the audit record of how the file got started.
Click “Add Instruction” — creates a bare alt-fo-shared-process-instruction-base child. Click Complete. The guard alt-fo-shared-dqr-enquiry-has-instruction checks ≥1 instruction exists before the enquiry can close.
Sarah picks the concrete instruction type — alt-fo-pi-process-instruction or alt-fo-wc-process-instruction — from a modal. A new instruction child is created in Draft; Sarah fills it in. One click per instruction type.
A phase-entry trigger reads the instructionTypes field from the original triage form and auto-spawns one instruction per selected type. “Add Instruction” stays visible for late additions — automation dials up, user capability doesn't dial down (CFG-RS-02).
Is this a new person, or someone we already know?
Sarah uses the Client Picker on the instruction's onboarding portal. She searches ODS and the PMS by name, email, or phone. If James already exists, she links the existing record. If not, she creates a new Person with the ODS-backed form.
Four flows cover every real case: promote a contact to a client, create a new entity, link an existing client, or import from the PMS.
No widget. Sarah creates an alt-global-shared-entity-client work item from the admin menu and adds it as a participant. Crude, but validates that the Client work type exists in the right place in the hierarchy.
The Client Picker widget is deployed. Searches by email → phone → name. Five orchestrated steps on creation: create ODS Person → create Client WT in Draft → add primary-subject participant → transition Client to Pending-Approval → link Enquiry to Client via client-related.
The Picker calls alt-fo-shared-vw-client-create — idempotent, with per-step rollback, guarded by an idempotency key. Four supported flows: promote-contact, create-new, link-existing, PMS-import. Phase-entry trigger spawns the partner-approval task automatically on Pending-Approval.
The partner decides. Who you act for is not a form field.
The Client is in Pending-Approval. In parallel, an authoritative conflict search fans out across every connected entity — directors, UBOs, related parties — and aggregates the result. David sees a single Client Context Panel that tells him everything he needs.
He approves with no compliance required, approves but requires compliance, or rejects. The partner's click is the decision; the task holds the audit forever.
Sarah creates a partner-approval task manually, assigns to David. David records a decision. No conflict search yet — she runs one outside the system for validation.
“Run Conflict Search” spawns an alt-fo-shared-process-conflict-search child. The AltConflictSearch action runs against the primary subject and contacts, records the result on the search child. The Client Context Panel widget renders it for David alongside his approval task.
Phase-entry on Pending-Approval fires two things in parallel: alt-fo-shared-vw-conflict-check (enumerates all 12 ODS-role entities, fans out AltConflictSearch, aggregates, flags), and alt-fo-shared-task-partner-approval (mode client-approval). David's decision auto-advances Client to Approved or Inactive. “Re-run conflict search” stays as a toolbox command — directors get added, searches get re-run.
Capture the matter details while they're fresh.
Client approved. Sarah shapes the instruction itself: matter type, billing defaults, responsible lawyer, responsible partner. Nothing here is surprising — but the system quietly checks the prerequisites in the background.
If something's missing, a task appears. If everything's there, the button to proceed becomes live.
Sarah advances Draft → Onboarding, types matter details into the description, then advances Onboarding → Converting. Validates the onboarding phase shape.
Onboarding form plus participant widget. Sarah fills matter type, billing defaults, assigns responsible lawyer and partner. Matter-compliance child is created manually when she clicks “Start Matter Compliance”. “Proceed to Converting” moves the phase forward.
alt-fo-shared-vw-instruction-onboarding fires on Onboarding entry: auto-spawns the matter-compliance child, validates prerequisites (client linked, matter type set, responsible partner assigned), surfaces a “missing prereq” task for the responsible lawyer if anything's absent. “Proceed to Converting” stays user-driven (CFG-RS-01 — user-driven transitions always possible).
The client is real. We verify.
Rachel works through the client compliance cycle: identity verification (powered by <strong>FirstAML</strong>), risk scoring (jurisdiction, industry, PEP), then partner sign-off on the risk score. When it's done, the Client's <code>complianceStatus</code> flips to Passed with a twelve-month expiry.
A year later, the cycle repeats. Every run is a self-contained record — you can stand behind any one of them in a regulator's audit.
Rachel creates a Client Compliance work item, advances phases (AML Verification → Risk Scoring → Approval → Complete) manually. No real AML lookup — just validates the lifecycle.
Rachel opens the AML task, records ID verification outcome. Opens the CRR (Client Risk Rating) form — jurisdiction, industry, PEP — system calculates the risk score. Partner-approval task in cycle-approval mode; David reviews and decides. Rachel updates the Client attributes on completion.
alt-fo-shared-vw-client-compliance drives the phases. On AML entry the VW auto-creates the task and calls FirstAML outbound. Five event-engine plans listen for inbound FirstAML events and update the Client's firstAmlCaseRef and identityVerificationStatus. Auto-advances AML → Risk → Approval → Complete on outcomes. “Re-fire FirstAML” stays as a toolbox command for support when automation is off.
The client is approved. Now the matter itself.
Client compliance answers ‘can we act for this person?’. Matter compliance answers ‘can we act on this matter?’. Practice area, activity type, the MRR — Matter Risk Rating. Partner signs off, and the compliance child completes.
The moment the platform fires <em>process-complete</em>, a re-evaluator plan upstream on the instruction hears it and re-checks whether the four conversion gates now all pass.
Rachel manually advances the matter-compliance phases. No forms, no tasks — just phase validation.
Classification form (practice area + activity), MRR form (matter-specific risk), partner-approval task (matter-compliance mode). Rachel drives each task to completion.
alt-fo-shared-vw-matter-compliance drives the transitions. On terminal, the platform fires a process-complete event. The Instruction's gate-2-reevaluator plan consumes it and re-runs the four-gate check automatically.
Four conditions. All must pass.
Before a matter is ever created, four things must be true: the client is approved, client compliance is complete, matter compliance is complete, and the partner has approved. If all four, the system proceeds. If not, it waits quietly and re-checks every time an upstream process finishes.
Nobody has to poll. Nobody has to remember. The re-evaluator subscribes and listens.
Sarah checks each condition herself and clicks “Create Matter” when she's satisfied. Validates the manual gate.
Same as Pass 1 — Sarah checks conditions on the Client, the compliance children, and the approval task, then clicks “Create Matter”. No re-evaluator yet; the matter is created as an instruction child manually.
alt-fo-shared-vw-instruction-gate-2-reevaluator subscribes to process-complete events from Client Compliance and Matter Compliance and to approval events. On every fire, it re-runs the four-gate check and writes gatesAllPassed = true when they all pass. alt-fo-shared-vw-instruction-converting guards on that flag before materialising the matter. “Override gate — force create” is available as an admin-only toolbox command for support scenarios.
The call hung up twelve minutes ago. The matter is live.
All four gates pass. The matter materialises in Sharedo. The Client record links. The case team copies across. Billing defaults land where they should. The PMS — Aderant, 3E, or Affinity — gets the matter and the client, and Sarah sends the engagement letter before lunch.
If the PMS push fails, a support-team task appears with the retry option one click away. The manual path never goes away — that's the whole point of resilient build.
Sarah manually creates a Matter work item as a child of the Instruction. Advances Instruction → Live. No PMS call yet.
“Create Matter” uses createWorkItem. Sarah copies client, case team, and billing defaults with “Copy from Instruction” ribbon commands. PMS provisioning is stubbed — a log entry, not a real push.
alt-fo-shared-vw-instruction-converting executes every step: create matter → link Client → copy case team via alt-fo-shared-wf-add-participant → copy billing via alt-fo-shared-wf-update-work-item → transition Instruction to Live → PMS provisioning fires on Client → Approved. On PMS failure exhaustion, escalation task appears for the support team. “Retry PMS” stays available forever as a toolbox command (CFG-RS-02).
Before · after
Four pain points every file opening team will recognise — and what happens to them once the journey you just walked is in place.
Before
Caller calls twice. Sarah types their details into the enquiry form, the conflicts search, the PMS client record, and finally the matter opening form. Four re-types, three opportunities for a typo.
After
One ODS-backed form. One Person record upserted and linked everywhere. Zero re-types. The enquiry is the audit trail of how the file got started.
Before
AML verification runs as a separate spreadsheet. Expires quietly twelve months later. Nobody notices until a regulator asks.
After
Compliance is a process — AML (powered by FirstAML), risk, partner sign-off. A scheduled renewal scan spawns the next cycle before expiry. Every cycle is a self-contained record.
Before
Partner approval is an email thread. Who approved what, and when? Hunt through inboxes. Hope it was captured.
After
Partner approval is a task. The Client Context Panel renders conflict results, directors, UBOs, prior matters — all in one screen. The click is the decision; the audit is automatic.
Before
Matter opening is a separate data-entry task in the PMS — done by hand, often days after the caller has moved on.
After
When the four gates pass, the matter materialises automatically in Sharedo and synchronises to Aderant, 3E, or Affinity. The manual retry button never goes away — because sometimes the PMS doesn't.
The difference
Automation removes the mechanical handoffs. Every minute saved is a minute the caller isn't re-explaining.
Every compliance cycle, every conflict search, every approval — a self-contained record you can stand behind in a regulator's audit.
PMS provisioning and AML verification ship as part of the product. No bespoke connector project.
Every automated step has a manual override. Resilient Build means a person can drive the whole journey when they need to.
The architecture
The whole product rests on one decision. Separate the things that just are — Clients, Matters — from the things that happen — compliance cycles, conflict checks, approvals. Entities hold the truth. Processes run a lifecycle, finish, and leave a complete record behind.
Hover an Instruction to see how it interacts with Client compliance.
Compliance-required. Client Compliance must be current — its AML (powered by FirstAML), risk and approval feed into this Instruction's gates. Common for new clients or higher-risk matters.
No Client compliance needed. Existing client, valid AML, light-touch work. The Instruction proceeds straight to its own gates and Partner Approval.
Held — Client compliance pending. An AML refresh is in progress. This Instruction holds in queue. Other Instructions on the same Enquiry can still progress in parallel.
POC · interactive
Click Client Compliance to flip between “current” and “refresh in progress”. Watch each Instruction react. The independent one never stops. AML powered by FirstAML.
AML currentAll three Instructions proceed to their own gates. The AML state is supplied to those that need it; the independent one ignores it.
Entities · Beings
A Client exists. A Matter exists. They change slowly — Draft → Active → Inactive — and the rest of the firm reads from them like a source of truth.
Processes · Doings
A Conflict Search runs. A Compliance cycle completes. Each one is a self-contained audit trail you can point at and say: this is what happened, this is who decided.
The enquiry spawns instructions and stays as the intake audit record. Nothing is rewritten in place.
Parent sets the child's inputs at creation. Children never modify their parent.
Each compliance cycle, each conflict search, each approval — self-contained, inspectable, audit-ready.
A person can drive the whole journey at every pass. Automation dials up; manual capability never dials down.
Where user judgement matters, the manual button stays on the ribbon — even after the workflow takes over.
Every phase transition writes a timestamped note to the work item's comment thread. Processes finish — they're never auto-closed out from under you. The trail stays readable for as long as the record exists.
The mental model
Most systems collapse identity, relationship, and work into one record — and then can’t answer simple questions like “is this the same Bob Smith as the UBO on that other client?” Sharedo splits them deliberately. ODS holds real-world identity, the Client work item holds the firm’s relationship state, and participants wire the two together. Matters and document templates read across the chain.
Hover a layer to see what it holds.
ODS — real-world identity. One record per real person or organisation, shared across the tenant. If Bob is a director of three different clients, that’s one ODS Person, referenced three times. Documents read names, DOBs, and addresses from here.
Client work item — the firm’s relationship. Sharedo’s record of “are we acting for Bob right now?” — phase, compliance status, PMS Client ID, engagement state. Linked to ODS via the primary-subject participant role (mandatory, exactly one). Contacts attach via ten per-category roles — director, UBO, authorised-signatory and the rest.
Work items — what we’re doing for the client. Enquiry, Instruction, Matter. Each carries a client participant pointing at the same ODS entity, plus a Regarding link back to the Client work item. The Matter inherits both — and a document template can read across all three layers in a single render.
Why three layers?
ODS changes rarely — Bob’s name, his address. The Client changes on engagement events — onboarding, AML, archival. Work items churn fast — every matter, every cycle. Splitting them lets each story tell itself without dragging the others along.
What a participant role actually is
A participant role on a work item points at an ODS entity and says “this person, in this role, on this work item.” primary-subject glues ODS to the Client; client on every Matter points at the same ODS so identity stays consistent.
Why documents read across
An engagement letter resolves {{client.name}} via the ODS layer, {{client.pmsRef}} via the Client work item, and {{matter.ref}} via the Matter — in one render. Once rendered, the document is an immutable snapshot of the chain at that moment.
The relationship types
The mental model above shows three layers. Zoom in on the lines between them and there are six distinct relationship types — each with its own cardinality, its own behaviour, and its own place in the audit trail. Hover a chip below the diagram to isolate just that kind of wire.
Hover a chip to isolate a relationship type.
primary-subject — the defining wire. A participant role on the Client work item; cardinality exactly one, mandatory. Points at the ODS Person or Organisation this Client represents. Without it, the Client is an orphan.
client-contact — ten per-category roles. Director, UBO, authorised-signatory, principal, power-of-attorney, guardian, next-of-kin, emergency-contact, insurer, unclassified. Cardinality 0..N. The role is the category — Sharedo participants don’t carry per-instance custom attributes (proven on POC). AML routing keys off the role name.
client role — identity on every work item. Each Enquiry, Instruction and Matter carries a client participant pointing at the same ODS entity as the Client’s primary-subject. That’s how identity stays consistent across the whole audit trail. Inherited at child creation; never mutated.
Regarding · client-related — the hub link. Sharedo’s OOB many-to-many relationship type, declared via Type Relationships as a type-pair (Client ↔ Enquiry, ↔ Instruction, ↔ Matter). Bidirectional navigation. Powers the Client’s “all matters” tab and the work item’s “back to client” link.
spawn — repeatable, auditable, never mutates parent. Platform-native parent-child work-item creation. Child inherits participants from parent at creation. SpawnMatter is the special flavour that pivots an Instruction into the OOB Matter root, gated by the four-condition converting gate.
read-from — doc templates traverse the chain. Not a stored relationship; a planned traverse at render time. A template tag like {{client.name}} resolves via roles.client!1.ods.person.name — ODS layer. Then {{client.pmsRef}} reads the Client work item. Then {{matter.ref}} reads the Matter. One render, three layers, immutable result.
Where to focus
Three short paths through this page depending on the seat you're sitting in.
If you're a Business Analyst
The Before / After band is the business case in four paragraphs. The outcomes band quantifies it. Scenes 2, 7, 9 show the guard logic and audit trails you'll need to explain to risk & compliance.
If you're a Responsible Partner
Scene 5 — Partner Approval shows what lands on your task list: the Client Context Panel, the conflict result across 12 role types, three decisions. Scene 9 is the four-gate check that means you never sign off on an unchecked matter.
If you're in IT or Compliance
The Entity-Process split is how we integrate at the seams, not the core. Scene 7 covers FirstAML event plans; Scene 10 covers PMS provisioning to Aderant, 3E or Affinity. Resilient Build answers “what do we run day one”.
How it's built
A person can drive the whole journey at every pass. We build a walkable skeleton, layer manual capability on top, then dial up automation — with manual paths preserved where they need to survive. Resilient Build, the Alterspective way.
Pass 1
Phase plans only. Click each phase transition by hand. We walk the whole journey with nothing but buttons — and we ask the business at the gate: does this lifecycle match how you actually work?
Pass 2
Add forms, roles, tasks, the portal. Drive every step by hand. The whole journey is now operable without any automation. We ask the business: can you run your day with these screens and these hand-offs?
Pass 3
Layer the workflows, triggers, event plans. Automation takes over the mechanical steps — create task, transition phase, call FirstAML, push to PMS. The user keeps the toolbox for everything that really needs a person.
See it in your firm
Alterspective's File Opening product runs on Sharedo and is being deployed with law firms now. Firms using it cut file opening from hours to minutes and replace the three-systems- and-an-inbox workflow with one guided journey. If that's the kind of change you're looking for, we should talk.