How I'd build Counsel
I'd run this on a Python/FastAPI backend with Next.js for the dashboard, Postgres as the database, and Twilio for inbound call routing. The voice flow would use OpenAI's Realtime API for low-latency agent response. This is a 280-320 hour build from first line of code to production-ready, which at 40 hours a week lands us in the seven to eight week range before you're handling your first real calls.
Day-by-day plan
- Day 1-2: Scaffold FastAPI project, set up Postgres schema (firms table, clients table, conflicts table, intake_records). Wire multi-tenant auth via Clerk. Seed a test firm and a handful of sample client records.
- Day 3: Build the Twilio inbound webhook, route calls to OpenAI Realtime, capture call_id for logging. Test with a burner phone.
- Day 4-5: Implement conflict checking logic. Query the clients table by name, company, and "adverse party" fields. Surface close matches to the agent mid-call. Log conflicts to a flag column that attorney sees on morning summary.
- Day 6-7: Build intake form schema, populate it from the call transcript and agent responses. Draft the retainer document template (PDF generation via ReportLab), pre-fill it with caller details and the firm's fee structure pulled from the firms table.
- Day 8: Build the morning digest. Query last night's calls, aggregate transcripts, flags, and draft retainers into a JSON summary. Email it via Resend to the attorney. Include a Loom-style call playback link.
- Day 9-10: Ship the firm dashboard. Show call volume, conflict hit rate, intake conversion (calls that turned into signed retainers). Add a settings page where attorneys configure after-hours windows, upload their conflict lists, and set retainer templates.
- Day 11-12: Implement Stripe billing. Three tiers: Starter (2 after-hours lines, $250/mo), Pro (5 lines, intake and retainer templates, $350/mo), Plus (unlimited, custom conflict checks, dedicated Slack channel, $500/mo). Wire Stripe to toggle feature flags in the schema.
- Day 13-14: Write acceptance tests. Mock Twilio webhooks, verify the conflict check queries the right table, verify the digest emails include all required fields. Test the PDF generation with a few retainer variations. Load test the Realtime endpoint.
What's hard about this build
The conflict-checking edge case is spiky. Callers will say "my company's cousin is suing me" or "my wife's law firm is representing the other side," and the agent needs to parse that into a discrete conflict without an attorney in the loop. I'd build this conservatively: any name match that's above 80% string similarity gets surfaced as a flag, and the attorney always has final say before the retainer moves to signed. The other major risk is retention death from integration expectation. Firms expect call transcripts and intake data to land in Clio or MyCase automatically. Without those connectors built before you go live, you'll onboard five firms and lose three within 30 days because your product adds friction instead of removing it. I'd budget 40 to 60 hours post-launch for basic Clio and MyCase OAuth integrations, or position the product upfront as "we do the intake, you paste the summary" and shift positioning once connectors are live.
What's fast because of AI
Claude lets me scaffold the FastAPI models and Pydantic schemas in minutes instead of a morning. The intake form schema, conflict-check query logic, and retainer template pre-fill logic all start from an agentic prompt that generates 80 percent correct code. I'd use Claude for writing the system prompt for the Realtime agent itself: enumerating edge cases like "caller is slurring speech" or "caller says opposing counsel is in the room," and how the agent should respond. That enumeration normally takes a week of user research and UAT. Here it's two prompts and a validation call. Copywriting for the dashboard UI, email digests, and error messages runs through Claude as well. And when I hit the inevitable 2 a.m. debugging session on call routing or Postgres query performance, Claude helps me enumerate the root causes and spot the bug in the logs within minutes instead of hours of grep and print statements.
How I'd hand it off
I'd ship a Loom walkthrough of the entire flow: making a test call, watching it hit the conflict check, seeing the digest email arrive, and approving the retainer. I'd write a runbook covering Twilio number provisioning, Postgres backup strategy, and alert thresholds (if call drop rate exceeds 5%, page on-call). For the first 30 days, I'd rotate on a shared pager with you. That covers the inevitable integrations questions, UX tweaks, and the first real conflict-check edge case that your actual clients surface. All credentials, Stripe test keys, Twilio SIDs, and database access land in a shared 1Password vault. Source code lives in a private GitHub repo with a CLAUDE.md file documenting the architecture and the known limits.