The Solo Lawyer’s Calendar + Deadline Stack (Without Buying Another App)

solo lawyer calendar deadline stack

You probably already own everything you need to run a defensible deadline system — the gap is the workflow connecting them.

This workflow is for solo lawyers and firms of two to five attorneys who are already paying for Google Calendar or Outlook, some flavor of practice management software, and at least occasional access to a court-rules service. The goal is a single, reliable chain: complaint or notice comes in, deadlines get computed, events land in calendar, nothing falls through because it lived only in someone’s head. No new software purchase required — though there’s one spot where you’ll need a court-rules service if you don’t already have one, and I’ll flag it clearly when we get there.

What you’ll need

  • Calendar: Google Calendar or Microsoft Outlook (either works; steps differ slightly)
  • Practice management software: Clio, MyCase, PracticePanther, or any PM tool that supports matter-level tasks and calendar sync
  • AI model: Claude (claude.ai, Pro plan at $20/month, or API) — used to compute deadlines from trigger dates
  • Court-rules service: Aderant CompuLaw, Zola Suite Calendar Rules, or LawToolBox — required for jurisdiction-specific rule sets (free fallback option discussed below)
  • Optional: Zapier or Make (for automating the calendar-write step if you’re comfortable with no-code tools)

Step 1: Identify your trigger dates the moment a matter opens

Every deadline chain starts with one or two trigger dates — the date of service, the filing date, the accident date, the contract execution date. The single most common failure mode in small-firm deadline management isn’t a miscalculated rule; it’s a trigger date that never got written down anywhere permanent. Fix this at intake.

When you open a matter in your PM software, immediately populate a custom field called “Trigger Date” and a second one called “Trigger Type” (service of process, filing, incident, contract execution — whatever applies). If your PM software doesn’t support custom fields at the matter level, a pinned note on the matter works. What matters is that the date lives in the system of record, not in an email thread.

Clio users

Use Clio’s custom matter fields (Settings → Custom Fields → Matters). Create “Trigger Date” as a Date field and “Trigger Type” as a text or dropdown. These fields surface on the matter dashboard and can be included in Clio’s report exports.

MyCase / PracticePanther users

Both platforms support custom fields at the case/matter level under Settings. Same structure: one date field, one text/dropdown. MyCase’s workflow automation (available on the Advanced plan) can trigger a task checklist from a custom field change, which is worth setting up if you’re on that tier.

Step 2: Run the Claude deadline-computation prompt

This is the step that replaces the twenty minutes of counting calendar squares. Paste the relevant section from the complaint, summons, or notice directly into Claude along with the prompt below. Claude reads the trigger date, applies the rules you specify, and outputs a plain-English deadline list you can copy into your PM software or calendar.

Critical framing before you use this: Claude computes arithmetic against rules you supply. It does not know your jurisdiction’s local rules, it cannot account for tolling, and it cannot replace a court-rules service for contested or high-stakes matters. Use this prompt to get a fast first draft of your deadline list. Verify every deadline against your court-rules service before it goes on the calendar as final.

You are a legal calendar assistant helping a lawyer compute procedural deadlines. You are doing date arithmetic only — you are not giving legal advice and you are not interpreting ambiguous rules.

INPUTS I WILL GIVE YOU:
- Trigger date: [DATE]
- Trigger event: [e.g., "date of service of summons and complaint"]
- Jurisdiction and court: [e.g., "U.S. District Court, S.D.N.Y." or "California Superior Court, Los Angeles County"]
- Applicable rules (I will paste the rule text or specify the rule number): [PASTE RULE TEXT OR CITE]
- Any known holidays or court closures I want you to account for: [LIST OR "none provided"]

TASK:
Using only the rules I have supplied above, compute the following deadlines from the trigger date:
1. [First deadline — e.g., "deadline to answer or otherwise respond under FRCP 12(a)(1)(A)(i)"]
2. [Second deadline — e.g., "Rule 26(f) conference — no later than 21 days before scheduling conference"]
3. [Add as many as needed]

For each deadline, output:
- Deadline name
- Rule citation (as I provided it — do not add citations I did not give you)
- Computed date
- How you calculated it (e.g., "30 calendar days from [trigger date], landing on a Saturday, moved to next business day Monday [date]")
- A one-line flag if the rule I gave you contains language you could not apply purely arithmetically (e.g., tolling conditions, "unless otherwise ordered," discretionary extensions)

Output as a numbered list. Do not guess at rules I did not provide. If a calculation requires information I have not given you, say so explicitly rather than assuming.

Fill in the bracketed fields before sending. For federal civil matters, paste the relevant FRCP text — it’s public domain and fits easily in the prompt. For state court matters, paste the applicable state rule section. The more precise the rule text you supply, the more reliable the output.

Claude’s output will include a computation note for each deadline (“30 calendar days from July 3, landing on August 2, a Saturday; moved to Monday August 4”). Read those notes. If Claude flags a line with “could not apply purely arithmetically,” that’s your signal to stop and check the court-rules service before proceeding.

Close-up detail shot of two hands on a laptop keyboard, the screen showing only abstract colored calendar grid shapes —

Step 3: Verify against your court-rules service — this step is not optional

Claude computed arithmetic. A court-rules service encodes the actual local rules, standing orders, and jurisdiction-specific calendar calculations — including the stuff that will get a motion denied or a case dismissed if you get it wrong.

Aderant CompuLaw covers federal courts and most state courts; it’s the legacy enterprise option, priced for larger firms but available to solos through some bar association partnerships. LawToolBox ($29–$49/month per user) is the better fit for solos and small firms — it integrates directly with Outlook and Microsoft 365, syncs deadlines to your calendar automatically, and covers all U.S. federal district courts plus most state courts. Zola Suite’s Calendar Rules module is built into Zola Suite’s PM platform, so if you’re already a Zola subscriber it costs nothing extra.

If you are not yet paying for any court-rules service: the free fallback is your state bar’s practice guides and the court’s own local rules PDF. It works, but it puts the rule-reading burden entirely on you. For a solo running volume litigation, even $49/month for LawToolBox is worth it — one missed deadline pays for years of the subscription.

Jurisdiction-specific situations where Claude’s arithmetic will not be enough, and where a court-rules service or careful manual research is mandatory:

  • Tolling rules — particularly in personal injury, medical malpractice, and cases involving minors or incapacitated parties. Tolling conditions are fact-specific and cannot be computed arithmetically.
  • State-specific “court day” vs. “calendar day” distinctions — California, Texas, New York, and others have rules that count differently depending on the motion type.
  • Local rules with standing orders — individual judges frequently modify the default rules. CompuLaw and LawToolBox track these; a generic AI prompt does not.
  • Removal and remand deadlines — the 30-day removal clock under 28 U.S.C. § 1446 has enough fact-pattern variation that you want a human rule set behind it.
  • Statute of limitations with discovery rules — the “discovery rule” for accrual is legal interpretation, not arithmetic. Claude can compute forward from a date you give it; it cannot determine what that date is.

Step 4: Enter deadlines into your PM software as tasks, not just calendar events

Calendar events get moved. Tasks with due dates tied to a matter leave a record. Enter your verified deadline list as matter-level tasks in your PM software — not just as calendar blocks — so they appear in matter history, show up in your task dashboard, and survive a calendar reorganization.

In Clio, use the Tasks tab on the matter and set each deadline with a due date and assignee (even if the assignee is just you). In MyCase, same pattern under the Tasks section. PracticePanther users: use the task list and check the “Link to Case” option so the task appears in both the global task view and the matter view.

The three-layer rule

For any hard deadline — court filing, response due, statute of limitations — enter it three times: (1) the actual deadline as a task in PM software, (2) a calendar event on the actual deadline date, and (3) a reminder task or calendar event 14 days out labeled “deadline in 14 days — [matter name].” This is not redundancy for its own sake. Courts do not care that your calendar app crashed.

Step 5: Sync PM software to Google Calendar or Outlook

Most PM tools offer a native calendar sync. Use it, but know what it does and doesn’t do.

Clio + Google Calendar: Clio’s native sync (Settings → Calendar Sync) pushes Clio calendar events to Google Calendar. Tasks do not sync — only events. This is why you need both the task entry (Step 4) and a calendar event. Set the sync to two-way if you want Google Calendar edits to reflect in Clio; be aware that a two-way sync means an accidental drag-and-drop in Google Calendar will move the event in Clio too.

Clio + Outlook: Same sync path, but uses CalDAV. Works reliably in Outlook desktop; Outlook on the web has occasional sync lag of up to 15 minutes.

LawToolBox + Outlook/Microsoft 365: If you chose LawToolBox in Step 3, its Outlook add-in writes computed court deadlines directly to your Outlook calendar as a series of linked events. This is the tightest integration available for Windows-based solos and saves the manual calendar-entry step entirely.

MyCase / PracticePanther: Both offer Google Calendar sync under Settings. MyCase’s sync is one-way (MyCase → Google) by default. PracticePanther’s sync is two-way. Same caution about accidental edits applies.

Where this breaks

Tolling is the biggest failure point. The prompt above explicitly cannot handle tolling — it can only compute forward from a date you provide. If the accrual date is contested, or if a discovery rule, minority tolling, or fraudulent concealment argument is in play, the trigger date itself is a legal question. Get that date right before you run any arithmetic.

Claude hallucinates rule citations when you don’t paste the rule text. If you ask Claude to “compute the answer deadline under California CCP § 412.20” without pasting the actual statute, it will often produce a plausible-sounding but wrong rule summary. The prompt above guards against this by requiring you to paste the rule text — but only if you follow that instruction. Skipping the paste step is the most dangerous shortcut in this workflow.

PM software calendar sync breaks more often than vendors admit. I’ve seen Clio’s Google Calendar sync drop events silently after a Google OAuth token refresh. Check your sync status monthly: open a test matter, create a test event in Clio, confirm it appears in Google Calendar within five minutes. If it doesn’t, re-authenticate the connection under Settings.

Local rules and standing orders change. CompuLaw and LawToolBox both maintain update teams; a rules PDF you downloaded last year may be stale. If you’re using the free-fallback method (manual rule lookup), build a quarterly review into your docket: pull the court’s current local rules page and compare against your saved copy.

The three-layer entry is only as good as the person doing it. If the workflow runs through one person and that person is out, the backup needs to know where to look. Document the workflow in a one-page internal SOP — where trigger dates live in the PM software, which calendar the events land on, and what the naming convention is for deadline events.

What this saves you

The deadline-computation prompt alone — when you have the rule text in hand — runs in under two minutes and produces a formatted list you can copy directly into your PM software task entry screen. Doing the same work manually, counting calendar squares and checking holiday lists, typically runs 15–25 minutes per matter depending on how many deadlines are in play. Across a practice opening 4–6 new litigation matters per month, that’s two to three hours back per month from one prompt.

The larger gain is error reduction. The workflow forces you to write trigger dates into the system of record at intake (instead of leaving them in email), separates arithmetic (Claude) from rule interpretation (you and the court-rules service), and creates three independent reminders for every hard deadline. None of that is glamorous. All of it is the kind of thing that keeps a solo practice out of malpractice exposure.

For solos and small firms running without a dedicated docketing clerk, this workflow closes the gap without adding a new subscription — provided you already have a court-rules service. If you don’t, LawToolBox at $29/month is where I’d start.

Related reading