Intake without the clipboard or the callback

The problem

Intake was a phone call and a clipboard.

Somebody injured calls the firm. A receptionist takes them through thirty-odd questions out loud. They’re told an attorney will call back, and they hang up knowing nothing — not what their claim might be worth, not what happens next, not even whether the firm is taking it. A paralegal then retypes the notes, looks up the state’s fault rules and filing deadline in a binder, and forms an opinion.

Every “what’s happening with my case?” call after that gets answered by hand.

And the questionnaire itself lived in a Word document. Changing a question meant a developer ticket, so it never changed.

What we built

A guided questionnaire the client fills in with no login at all, ending in a plain-English summary and a rough range — on screen, in seconds, with the reasoning shown.

That range isn’t a lookup table. It runs through six stages. First the answers are read into a strict structure. Then that state’s own rules are applied — how shared fault works there, the filing deadline, any cap on damages — from a fifty-state table, and the process can stop outright where the law blocks it. Comparable outcomes, an independent judgment stage and a deliberately pessimistic “lowest number we could still defend” stage all run at the same time.

Then, importantly, every dollar figure is calculated in code, not by a model. Losses without paperwork are weighted down before anything is multiplied — undocumented medical bills count for half, unreported cash wages don’t count at all. In states where sharing fault bars a claim, the range collapses accordingly. The range gets wider the more information is missing, held between five and sixty percent, and the result is rounded to a sensible number. Confidence comes from that width and is stated openly, alongside what pushed the number up, what pulled it down, and what the client could provide to improve the estimate. The whole working is saved for the firm to look at.

The lead becomes a client account through an emailed link, and the case moves through six named stages the client can see: New, Under review, Documents needed, Negotiating, Settled, Closed. Every stage change and every note posted by staff sends an email automatically.

And the questionnaire is now the firm’s to change. A partner drags questions into order, groups them onto pages, and splits or merges pages right in the browser. The layout is saved on the questions themselves and written through one carefully checked step, so there’s no developer involved and no way to lose a question by dragging it.

The result

A potential client gets a clear, explained answer in the same sitting instead of waiting for a callback, which is the difference between a lead and a lost one. Intake staff stop transcribing and start reviewing.

The stage of the case is visible to the client, so the “any update?” calls fall away on their own. Every notification that goes out is logged along with what happened to it, so nobody has to wonder whether the client was told.

And the questionnaire is a living document again. Because it can be changed in an afternoon, it does get changed — which is worth more than any single question on it.

Why it holds up

• 397 automated tests, weighted towards exactly the parts that must not drift: the damages math, the state-law gates, the pipeline, and the drag-and-drop layout logic.
• The process heals itself. A run that goes quiet is failed automatically, so a deployment mid-estimate can’t leave a case stuck waiting forever.
• Security isn’t an afterthought. Strong password hashing, links stored only as fingerprints, seven-day claim links and one-hour password resets, limits on repeated attempts at intake and login, automatic HTTPS and a strict content policy — and the app refuses to start in production on a default password.
• One command to install, update or remove, with database changes and starter data applied safely every time.