Automating Legal Case Intake with AI

The Problem: Intake Was the Bottleneck

Before this project, a Canadian personal injury law firm was running client intake almost entirely by hand: paper claim forms, manual document collection, and case details re-typed into different systems at every stage. None of that work was complicated — it was just slow, and it delayed the point where a case actually started moving.

I built a case intake platform to replace that process end-to-end. It now manages 470+ active client files with automated claim forms and workflow routing, on a stack of Django REST Framework, Next.js, and PostgreSQL. Here is what that actually involved.

Understanding the Real Bottleneck

The first step was not writing code — it was mapping the existing process. Manual intake for a law firm usually breaks down the same way:

• A new client's information arrives as a paper form, an email, or a phone call
• Someone has to read it and re-enter it into the firm's case management system
• Supporting documents get collected separately, often out of order
• The case does not move forward until all of that is complete and correct

Every one of those steps is a place where a case can stall for days without anyone doing anything wrong — the process itself is just slow by design.

What We Built

Digital claim forms, not paper

The starting point was replacing paper intake forms with structured digital ones — built to capture exactly the fields the firm's workflow actually needs, not a generic form template.

Automated document collection

Instead of chasing supporting documents by phone and email, the system handles structured document collection as part of intake, so files are attached to the right case from the start instead of arriving separately and needing to be matched up later.

Workflow routing that matches how the firm actually works

Once a case enters the system, it needs to reach the right person at the right stage. The platform automates that routing — new intake goes where it needs to go without someone manually forwarding it.

A PostgreSQL backend built for real case data

Legal case data is relational by nature: clients, cases, documents, and status all need to stay connected and queryable. PostgreSQL, with a Django REST Framework API in front of it, gave the system a reliable structure to build the rest on top of.

A Next.js interface the team actually uses

None of this matters if the team does not use it day to day. The interface was built around the actual intake workflow — new case, client details, document status, case progress — rather than a generic admin panel bolted onto a database.

Handling Sensitive Data Correctly

Legal case data is not generic form data — it involves personal and often medical information tied to an active claim, so data handling was not an afterthought. Access to case files is scoped by role, so someone reviewing new intake does not automatically see every active case in the firm. Every stage of the workflow is built to keep client data structured and access-controlled rather than sitting in shared inboxes or spreadsheets, which is where a lot of firms unintentionally end up with their most sensitive information.

Why Django REST Framework, Next.js, and PostgreSQL

This stack was not the default choice — it was the right fit for what the system actually needed to do:

• PostgreSQL because legal case data is inherently relational — clients connect to cases, cases connect to documents and status history — and that structure needs to stay queryable and consistent as the firm's caseload grows.
• Django REST Framework because the business logic around intake (validation, routing rules, permissions) benefits from a mature, structured framework rather than a lighter API layer that would need that logic built from scratch.
• Next.js for an interface that is fast for the team to use daily, without the overhead of a heavier admin framework that would fight against the firm's actual workflow.

The Results

• 470+ active client files currently managed through the platform
• Automated claim form and intake workflows — no more manual re-entry between systems
• Faster, error-free case onboarding — cases start moving as soon as intake is complete, not days later

The measurable win is speed, but the less obvious one is consistency — every case now goes through the same structured process, instead of quality depending on who happened to handle a particular intake that day.

What This Looks Like for Other Firms

This project was built for a personal injury law firm, but the underlying problem is not law-firm-specific. Any business where intake means "collect information, gather documents, and route it to the right process" — real estate, home services, professional services — has the same structural bottleneck, and the same kind of system fixes it.

Thinking About Automating Your Intake Process?

If your team is still running client or case intake manually — paper forms, email chains, manual data entry — it is very likely costing you more time than it should. Get in touch to talk about your process, or read more about AI automation for business processes.