800% order growth, zero missed home closings

Custom notaries

Assign a specific notary when a signing calls for one, instead of letting Core auto-source.

Draft signings

Save an incomplete signing and pick it back up later, without re-entering what’s already there.

Comm tagging

Tag emails, voicemails, and faxes to an order; they surface as tasks for the right scheduler.

Convert an active signing to a split signing

Turn a live signing into a split without unwinding and rebuilding it.

Pre-fill everything you already know.

Manual entry was the scheduler's biggest time sink and a steady source of errors. The obvious fix — a cleaner form — still asks the human to transcribe data the system already has.

So Core pre-fills every field it can derive from the order: signing location, signing type, parties, notary preference, special instructions, even the time zone (pulled straight from the location). The only thing left for the human is the time and date. The job changes from data entry to a quick verification — the scheduler stops being a typist and becomes a checker.

Toggles, not a thousand fields.

Scheduling is a swamp of edge cases, split signings chief among them. The tempting approach is a form that anticipates every one — which collapses under its own weight. The opposite failure is a clean form that quietly can't handle the case in front of you.

We put a row of toggles at the top. The scheduler — who knows the case — flips the toggle for the situation they're in, and the form contextually adds or removes the fields that matter. The complexity is there when you need it and invisible when you don't. We let the human's knowledge drive disclosure instead of trying to model every branch in a static layout.

The machine should only ask for a human when it needs one.

Schedulers spent their days monitoring healthy appointments to catch the rare one in trouble — in Looker reports, by hand. Full automation with no oversight is dangerous when a missed signing means a missed closing. Full manual monitoring is tedious and misses things anyway.

The resolution was the tasking engine. Core listens for problems in the background and surfaces a task only when judgment is required. The canonical example: it's six hours to signing and SnapDocs still hasn't confirmed a notary. Core raises a task — find a notary, or in the worst case reschedule or cancel — to a human who can actually decide. The rest of the time, no one is watching, because nothing needs watching.

A reschedule is never just a reschedule.

Change a signing date and the consequences fan out: documents regenerate, other departments have to move. In an org where most processors work remotely, that's exactly where context gets dropped — and a dropped handoff becomes a missed closing.

So a reschedule doesn't just update a date. It triggers the downstream tasks automatically, routing work to the departments that need it. The design problem looked like a calendar change; it was really about making remote communication reliable without anyone having to remember to send it.

Let schedulers fix a split signing without starting over.

This one came straight from research. Schedulers often learn that a signing needs to be split only after they've already scheduled it. In Resware, fixing that meant unwinding the whole appointment by hand and rebuilding it — enormous effort, enormous coordination.

We designed the opposite: save the original signing and add splits onto it. The system absorbs the change instead of punishing the person for discovering it late. The happy path isn't where the work ends — and the tool shouldn't assume it is.

You can't supervise someone's kitchen table — so score who you send to it.

The entire closing comes down to one independent contractor showing up at a borrower's home and doing their one job right — and that was the part Doma controlled least. Notary signing is a largely unregulated profession,^[5] and the loan hinges on how well that single person performs, often the only Doma-adjacent human the borrower ever meets.^[6] A meaningful share don't perform: no-shows and last-minute cancellations that detonate a closing,^[7] sloppy errors that keep a loan from funding, and — genuinely — the occasional notary who turns up to a kitchen-table signing impaired. Humans are unreliable screeners of this anyway; in one study, notaries correctly flagged identity imposters only about 72% of the time.^[8]

You can't manually vet every notary for every signing at Doma's volume, and you can't put a supervisor in the room. So we designed scheduling to lean on a risk signal instead of a hope: SnapDocs' notary scoring combined with Doma's own proprietary algorithm, which predicted the likelihood of a notary behaving badly. Scheduling routed around the risky ones before they were ever assigned. Rating notaries by score and blacklisting poor performers was already Doma's posture on the record;^[10] scheduling made that judgment automatic, before anyone reached a borrower's door. The design problem wasn't a screen — it was the decision to treat who shows up as a scored, systematized risk rather than a coin flip, and to build the assignment flow around that score.

Assume the integration will let you down.

Our early designs leaned on the SnapDocs API behaving a particular way. Halfway through, I found out it wouldn't — and the vendor never came back to confirm whether that capability even existed.

Rather than gamble the release on a dependency I couldn't control, I designed a backstop: a path that assumes that part of the API isn't available and still gets the scheduler to a confirmed signing. The automation degrades; the closing doesn't. Designing for the integration I actually had — not the one I'd been promised — is the only reason the timeline held.

The best interface is the one nobody has to use.

The win here wasn't a beautiful form — it was that the scheduler barely touched it. Most of the design work was deciding what the human should not be responsible for, then building the system to carry it. Designing the job down to its judgment calls was the whole point.

Design for the integration you have, not the one you were promised.

The SnapDocs assumption broke mid-project and the vendor never confirmed otherwise. The backstop is the only reason we shipped on time. Treat every external dependency as something that will fail, and design the fallback before you need it.

The happy path ends where the real work begins.

The split-signing insight only surfaced because we asked what schedulers do after they think they're done. Real workflows are full of "oh, actually—" moments. Designing for the correction is often worth more than polishing the first pass.

In a 200-year-old industry, every estimate is optimistic.

This was scoped at two weeks. Discovery alone made it clear it was a two-month project — and that was the right call. In a domain this old and this tangled, the work is always deeper than it looks, and the time spent understanding it is what makes the design hold up.