From a stack of court papers to a ready-to-serve job in one upload
A client portal and staff app where uploaded court documents become structured process-service jobs, with AI doing the first read and people confirming it.
Every process-service job starts with paper. A law firm sends a summons, a complaint and a few exhibits. Someone at the serving firm reads them, finds who is being served and where, notes the court, the case number and the parties, checks for any special instructions, and types it all into a job. Only then can a server be dispatched. That reading-and-typing step happens on every job, it's tedious, and it's where wrong addresses and missed deadlines begin.
At a glance
| Client | Mithra, a process-serving and investigations firm, building its next-generation platform with Hussar Investigations |
| Industry | Legal support |
| What we built | A client portal for ordering jobs, a staff app ("Saber") for running them, and the backend that connects them |
| Where AI fits | An extraction step reads the uploaded court documents and pre-fills the job: recipient, address, court, case number, parties, instructions and which documents get served |
| Stack | A Python API service, two Next.js web apps, a Postgres database, Stripe payments, and cloud hosting defined as code (Terraform on AWS) |
| Status | A document-to-job intake platform for process servers |
The old way
- A law firm emails or uploads a bundle of PDFs and asks for service.
- Office staff open each document to find the recipient's name and address.
- They copy the court name, case number, plaintiff and defendant into the job record.
- They read the cover letter for instructions such as "one attempt must be made by 5/27" or "try once in the morning, once at night".
- They work out which documents are to be served and which are just for reference.
- Only then is the job ready to assign to a server, and any typo travels with it into the field.
What we built
A client portal. Law firms and other clients sign in, submit a case, upload documents, follow progress, message the office and pay online. Uploads are split into documents to be served and reference material.
AI autofill on submission. When a client uploads the papers, the backend sends them to an OpenAI model (GPT-4.1 mini by default) with a tightly specified extraction brief. It returns structured data for the recipient, the court, any service instructions, and a classification of every document (summons, complaint and so on, and whether each is to be served). The recipient and court sections each carry a confidence score from 0 to 1, and the response must be valid JSON that matches a strict schema, or it's rejected. The client sees a pre-filled job to confirm and correct, not a blank form. Autofill can be switched off.
Saber, the staff app. The office side covers job assignment and search, a strategic map, a route planner for servers, field sheets for logging each attempt, door-tag management, e-signature, notary steps, status reports and analytics.
A shared backend. One service runs the portal, Saber and the office tools, with a process-service data model covering cases, recipients, addresses, documents, attempts, court information and service preferences.
How the workflow changes
| Step | Before | After |
|---|---|---|
| Receiving the papers | PDFs arrive by email and are saved by hand | The client uploads them straight into a case in the portal |
| Finding the recipient | Staff read every page to find who and where | The AI pre-fills recipient and address, with a confidence score |
| Court and case details | Typed in from the caption | Pre-filled: court, case number, plaintiff, defendant |
| Special instructions | Easy to miss in a cover letter | Pulled out as a list on the job |
| Which documents to serve | Sorted by hand | Each document classified and flagged "to be served" or not |
| Dispatch and field work | Phone calls, paper sheets | Assignment, route planning, field sheets and e-sign in Saber |
The person stays in charge: the AI does the first read, and the client or office confirms it. The repetitive part goes away, and the judgment stays with people.
How it works
Under the hood
- Structured output, or nothing. The model must answer in JSON. The answer is parsed and validated against a typed model before anything reaches the job, and a malformed response is an error, not a half-filled form.
- Confidence where it matters. The recipient and court data each come with a 0-1 confidence, so a low-confidence read can be flagged for a careful human check.
- Low creativity on purpose. Extraction runs at a low temperature (0.1), so the model transcribes rather than improvises.
- Swappable model. The model is a setting, not code, so it can be upgraded or swapped without a release.
- Infrastructure as code. Production hosting, load balancing and DNS are defined in Terraform, so the environment can be rebuilt rather than hand-assembled.
By the numbers
The platform was built by Gary of Hussar Investigations and Second Voyage. Gary led the backend and the document-processing service. Second Voyage built much of the client portal and the Saber staff app. As of November 2026:
- 125 commits on the main line
- about 72,000 lines of code across the portal, Saber and the backend
- a 16-table process-service data model
- Stripe checkout built in
Example scenario
Example scenario (illustrative): A small serving firm receives a dozen new jobs each morning from three law firms. Instead of an assistant spending the first hours of the day keying captions and addresses, each firm uploads its papers to the portal. The jobs arrive pre-filled, and the one with a low-confidence address is marked for a second look. The office checks the instructions list, sees that one job needs an attempt before Friday, and assigns it first. By mid-morning the servers already have their routes.
What this means for your business
Any business that turns incoming documents into work orders can use the same pattern: AI reads first, a person confirms, and the system keeps the structured result.
- Law firms and legal support companies: intake of filings, subpoenas and discovery requests.
- Title, escrow and insurance back offices: pulling parties, policy numbers and deadlines from incoming packets.
- Field service companies: turning emailed work orders into dispatchable jobs.
- Any operation where staff re-type PDFs into a system before the real work can begin.
Second Voyage builds AI systems that are held to a standard you can check. Talk to us about yours.