Microsoft Access for Law Firm Case Management: The Complete Guide

Reviewed by the Excel & Access Developers team — 15+ years building matter-management, conflict-check, and time-billing systems for solo practitioners through 40-attorney firms. Updated August 2026.

Quick answer: Microsoft Access can run law firm case management—clients, matters, conflict checks, deadlines, tasks, documents, and time entries—for solo practitioners and firms up to roughly 15–20 timekeepers who want a system built around their workflow instead of a template. It struggles once a firm needs a public client portal, multi-jurisdiction LEDES e-billing, or IOLTA trust accounting with zero room for error. Below: how to build it correctly, what actually breaks it, and when to graduate to something bigger.

Key takeaways

• Access comfortably handles matters, conflicts, deadlines, tasks, documents, and time for firms with roughly 2–20 concurrent users.
• A properly split front end / back end is the difference between a reliable case system and a Friday-afternoon corruption crisis.
• Conflict-of-interest checking is genuinely possible in Access—most "Access vs. Clio" articles never mention it, but it's one of the first things a real firm needs.
• Access is not a substitute for dedicated practice software once you need client portals, LEDES e-billing, or airtight IOLTA trust accounting.
• The hard file-size ceiling is 2GB and the realistic concurrent-user ceiling is 15–20 people—plan your migration path before you hit either one.

If your current system is a shared Excel workbook of open matters plus a Word folder named by client, you're already past what a spreadsheet can safely hold—see Excel spreadsheet vs Access database. For a real build, see the law firm time billing case study.

What Is Microsoft Access, and Can It Really Run a Law Firm?

Microsoft Access is the relational database engine bundled with Microsoft 365—think of it as a version of Excel that enforces relationships instead of letting you copy-paste the same client name into forty different rows. For a law firm, that distinction is everything: a matter belongs to a client, a deadline belongs to a matter, a time entry belongs to an attorney and a matter, and a conflict check has to look across all of them at once. Access was built for exactly this kind of linked, rule-bound data, which is why matter-tracking systems have been one of its most common small-business use cases for two decades.

That said, Access is a platform, not a product. Clio, MyCase, and PracticePanther arrive with case management already built. Access arrives empty—you (or a developer) build the tables, forms, and reports around how your firm actually works. That's the trade-off: more control and no per-seat subscription, in exchange for someone building and maintaining it.

Why Firms Choose Access Over (or Alongside) SaaS Practice Software

Familiar Windows tooling already in the office

Most firms already run Microsoft 365 on Windows. Staff know the Office UI; Access sits beside Outlook and Word without introducing a new browser product for every internal screen.

Custom matter fields without SaaS lock-in

Need a local-court checklist field, a conflict-check flag, or a referral-source column no practice template includes? In Access that's a field, a form control, and a report column—not a vendor feature-request ticket.

Fits small practices and internal-only workflows

Access is a strong fit for a small office LAN (or managed remote desktop), a handful of concurrent editors, and workflows that stay internal. When every client expects a portal and mobile intake, plan a practice-platform path deliberately. Scaling pitfalls: common mistakes when scaling an Access database.

Full control over retention, backups, and data ownership

A properly split, backed-up Access system keeps matter data entirely under the firm's own backup policy—no vendor outage, no export negotiation if you switch tools later. That matters for retention and ethics rules even if you add SaaS for client-facing pieces down the line.

Core Case Data: What a Law Firm Access Database Should Track

Clients and contacts

A Clients table (the entity) plus a Contacts table (people at that entity) keeps phone and email consistent across every matter. Conflict notes and engagement dates belong here—not pasted into every time row.

Matters (cases)

Matters hold matter number, practice area, status (Open, Closed, On Hold), open/close dates, responsible attorney, and `ClientID`. Queries answer "open matters by attorney" without anyone hunting through folders.

Conflict-of-interest checks (the part most Access guides skip)

Before a firm can open a matter, it has to know whether anyone involved—the new client, the opposing party, a witness, a related company—has shown up in a prior matter on the other side. This isn't optional; it's an ethics requirement in every US jurisdiction, and it's the feature that separates a real case management system from a glorified contact list.

In Access, a conflict check is a query that searches every name field across Clients, Contacts, and an AdverseParties table (opposing parties, witnesses, and related entities tied to each matter) for a name match, then hands the reviewing attorney a list to clear or flag. It doesn't need fuzzy matching or AI to be useful—a well-indexed `Like` query catches the vast majority of real conflicts, and a person still has to sign off either way. Run this from a button on the intake form before the matter record is allowed to save, not as an afterthought after the retainer is signed. Full VBA example below in Step 5.

Deadlines and the tickler system

Litigators call this a tickler system—a standing list of upcoming deadlines pulled from a rules-based calendar (service dates, filing deadlines, statutes of limitations) instead of one person's memory. In Access, that's a Deadlines table tied to `MatterID`, a `DueDate`, a `DeadlineType`, and a completed flag, plus a saved query or report surfacing anything due in the next 7, 14, or 30 days.

One honest caveat: for jurisdictions with complex rule-based deadline math (e.g., "21 days from service, excluding court holidays"), most firms still calculate the trigger date in a dedicated legal calendaring tool or manually, then enter the result into Access. Access doesn't know your local court rules out of the box, and building that logic in VBA is a bigger project than most firms actually need.

Tasks and workflow checklists

Tasks (matter, assignee, due date, status) cover discovery checklists, filing steps, and intake follow-ups. Templates can auto-seed tasks when a matter opens with a small amount of VBA.

Time entries and simple billing

TimeEntries (matter, attorney, date, hours, rate, narrative, billable flag) support WIP tracking and draft invoices. For a worked example of a time-focused legal system, see law firm time billing.

Document index (not a DMS replacement)

Store Documents metadata (matter, title, path or DocID, date) so staff can find the engagement letter path in seconds. Access is an index here—not a full document management system with versioning, check-in/check-out, and OCR.

Microsoft Access vs. Excel for Matter Tracking

Deeper spreadsheet limits: signs your business has outgrown Excel. Platform comparison: Excel spreadsheet vs Access database.

Microsoft Access vs. Clio, MyCase, PracticePanther, and Smokeball

Access is a database platform you shape. Clio-class tools are finished products with portals, payments, and e-billing built in. Neither is universally better—they solve different problems.

Industry context: legal solutions.

Which Approach Fits Your Firm's Size

Common Problems Law Firms Hit With Access

Most failures are file-sharing and design issues: one mega `.accdb` on Wi-Fi, no split, or a spreadsheet-shaped "matters" table everyone edits directly.

• File will not open → [Access database will not open](/blog/access-database-wont-open-fix)
• Locked for editing → [Access database locked for editing](/blog/access-database-locked-for-editing-fix)
• Corruption → [corruption recovery](/blog/access-database-corruption-recovery) and [prevention](/blog/prevent-access-database-from-corruption)
• Slow with years of time entries → [multi-user best practices](/blog/access-database-multi-user-best-practices) and [why Access slows with large data](/blog/why-access-slow-large-data)
• Growth mistakes → [scaling mistakes](/blog/common-mistakes-when-scaling-ms-access-database)

Split front end and back end

Data lives on a stable server share; each workstation gets a front-end copy with forms, reports, and VBA. A linked-table path breaking after a server rename is a top cause of "the case system is down" mornings.

Never sync the back end through OneDrive, Dropbox, or Google Drive

This one gets skipped in almost every "Access for law firms" article, and it's the cause of a large share of the "locked for editing" and corruption tickets we see. Cloud sync clients lock and re-write files in ways Access's own file-locking scheme doesn't expect. Put the back end on a real server share (or a proper VPN-accessible drive), not a synced folder.

Concurrent editors and locking

Paralegals and attorneys editing one unsplit file is how locks and corruption start. Split early; stop emailing a "master" database around the office.

Spreadsheet-shaped "databases"

One row with Client, Matter, OpposingCounsel, JanHours, FebHours… fails the moment a client has three matters or a deadline moves. Separate entities and keys—see how to design an Access database and table relationships.

How to Build a Law Firm Case Management Database in Access

Step 1: Define clients, matters, conflicts, deadlines, and time as separate tables

Step 2: Set primary keys and relationships

AutoNumber keys (`ClientID`, `MatterID`, `DeadlineID`, `TimeEntryID`, `AdversePartyID`). Foreign keys on the many side (`Matters.ClientID`, `Deadlines.MatterID`, `TimeEntries.MatterID`, `AdverseParties.MatterID`). If you want auto-generated matter numbers (see Step 5), add `MatterYear` (Integer) and `MatterSeq` (Long) fields to Matters. Enforce referential integrity so you cannot delete a matter that still has time, deadlines, or adverse parties attached.

Step 3: Build matter and deadline forms

Use a main form / subform: matter header on top, deadlines/tasks/time in subforms. Require `MatterID` and `DueDate` on deadline intake so a blank statute row can never save.

Open all deadlines for the current matter (button on matter form):

Private Sub cmdOpenDeadlines_Click()
    On Error GoTo Handler

    If IsNull(Me!MatterID) Then
        MsgBox "Save the matter record first.", vbExclamation
        Exit Sub
    End If

    DoCmd.OpenForm "frmDeadlines", _
        WhereCondition:="MatterID = " & Me!MatterID

    Exit Sub
Handler:
    If Err.Number = 2501 Then
        Debug.Print "OpenForm canceled: " & Err.Description
    Else
        MsgBox "Could not open deadlines: " & Err.Number & " — " & Err.Description, vbCritical
    End If
End Sub

Add a deadline with defaults (new-record button):

Private Sub cmdNewDeadline_Click()
    On Error GoTo Handler

    Dim matterId As Long

    If IsNull(Me!MatterID) Then
        MsgBox "Select a matter first.", vbExclamation
        Exit Sub
    End If

    matterId = CLng(Me!MatterID)

    DoCmd.OpenForm "frmDeadlines", DataMode:=acFormAdd
    Forms!frmDeadlines!MatterID = matterId
    Forms!frmDeadlines!DateCreated = Date
    Forms!frmDeadlines!Completed = False
    Forms!frmDeadlines!DeadlineType = "Filing"

    Exit Sub
Handler:
    MsgBox "Could not create deadline: " & Err.Number & " — " & Err.Description, vbCritical
End Sub

Step 4: Automate time entry and deadline alerts

Quick time entry from the matter form:

Private Sub cmdLogTime_Click()
    On Error GoTo Handler

    Dim db As DAO.Database
    Dim rs As DAO.Recordset
    Dim hours As Double

    If IsNull(Me!MatterID) Then
        MsgBox "Save the matter first.", vbExclamation
        Exit Sub
    End If

    If IsNull(Me!txtHours) Or Not IsNumeric(Me!txtHours) Then
        MsgBox "Enter hours as a number.", vbExclamation
        Exit Sub
    End If

    hours = CDbl(Me!txtHours)
    If hours <= 0 Then
        MsgBox "Hours must be greater than zero.", vbExclamation
        Exit Sub
    End If

    Set db = CurrentDb
    Set rs = db.OpenRecordset("TimeEntries", dbOpenDynaset, dbAppendOnly)

    rs.AddNew
    rs!MatterID = Me!MatterID
    rs!AttorneyID = Nz(Me!ResponsibleAttorneyID, 0)
    rs!EntryDate = Date
    rs!Hours = hours
    rs!Rate = Nz(Me!DefaultRate, 0)
    rs!Narrative = Nz(Me!txtNarrative, "")
    rs!Billable = True
    rs.Update

    rs.Close
    Me!txtHours = Null
    Me!txtNarrative = Null
    MsgBox "Time logged.", vbInformation

    Exit Sub
Handler:
    MsgBox "Could not log time: " & Err.Number & " — " & Err.Description, vbCritical
End Sub

Flag deadlines due within N days (admin button; test on a copy):

Public Sub FlagUpcomingDeadlines(Optional daysAhead As Long = 14)
    On Error GoTo Handler

    Dim db As DAO.Database
    Dim sql As String

    Set db = CurrentDb

    sql = "UPDATE Deadlines SET UpcomingFlag = True " & _
          "WHERE Completed = False " & _
          "AND DueDate >= Date() " & _
          "AND DueDate <= DateAdd('d', " & daysAhead & ", Date())"

    db.Execute sql, dbFailOnError
    MsgBox db.RecordsAffected & " deadline(s) flagged as upcoming.", vbInformation

    Exit Sub
Handler:
    MsgBox "FlagUpcomingDeadlines failed: " & Err.Number & " — " & Err.Description, vbCritical
End Sub

Step 5: Add conflict checking and automatic matter numbering

Run a conflict check across Clients, Contacts, and AdverseParties:

Public Sub RunConflictCheck(searchName As String)
    On Error GoTo Handler

    Dim db As DAO.Database
    Dim rs As DAO.Recordset
    Dim sql As String
    Dim safeName As String
    Dim resultsText As String
    Dim hitCount As Long

    If Len(Trim(searchName)) = 0 Then
        MsgBox "Enter a name to check.", vbExclamation
        Exit Sub
    End If

    ' Escape apostrophes so names like O'Brien or D'Angelo don't break the query
    safeName = Replace(searchName, "'", "''")

    Set db = CurrentDb

    sql = "SELECT 'Client' AS SourceTable, ClientName AS MatchedName " & _
          "FROM Clients WHERE ClientName Like '*" & safeName & "*' " & _
          "UNION ALL " & _
          "SELECT 'Contact', FirstName & ' ' & LastName " & _
          "FROM Contacts WHERE (FirstName & ' ' & LastName) Like '*" & safeName & "*' " & _
          "UNION ALL " & _
          "SELECT 'Adverse Party', PartyName " & _
          "FROM AdverseParties WHERE PartyName Like '*" & safeName & "*'"

    Set rs = db.OpenRecordset(sql, dbOpenSnapshot)

    hitCount = 0
    Do While Not rs.EOF
        resultsText = resultsText & rs!SourceTable & ": " & rs!MatchedName & vbCrLf
        hitCount = hitCount + 1
        rs.MoveNext
    Loop
    rs.Close

    If hitCount = 0 Then
        MsgBox "No conflicts found for """ & searchName & """.", vbInformation, "Conflict Check"
    Else
        MsgBox hitCount & " potential match(es) found — review before proceeding:" & vbCrLf & vbCrLf & resultsText, _
            vbExclamation, "Conflict Check — Review Required"
    End If

    Exit Sub
Handler:
    MsgBox "Conflict check failed: " & Err.Number & " — " & Err.Description, vbCritical
End Sub

Auto-generate a matter number like 2026-0001:

Public Function NextMatterNumber() As String
    On Error GoTo Handler

    Dim currentYear As Integer
    Dim lastSeq As Variant
    Dim newSeq As Long

    currentYear = Year(Date)
    lastSeq = DMax("MatterSeq", "Matters", "MatterYear = " & currentYear)

    If IsNull(lastSeq) Then
        newSeq = 1
    Else
        newSeq = lastSeq + 1
    End If

    NextMatterNumber = currentYear & "-" & Format(newSeq, "0000")
    Exit Function
Handler:
    NextMatterNumber = currentYear & "-ERR"
End Function

Wire `RunConflictCheck` to a button on the new-matter intake form, and call it before the record is allowed to save. These five steps are starter patterns—not a full ethics, trust, or e-billing system. Most production firms add rate cards, invoice batches, and a formal audit trail with a developer once daily reliance kicks in.

Security, Ethics, and Trust-Accounting Considerations

Modern `.accdb` files dropped the old Access workgroup (`.mdw`) security model, so "who can see what" has to be built rather than assumed:

• Access control: a simple login table plus a VBA gate on startup (or Windows-level NTFS permissions on the back-end share) restricts who can open sensitive tables like TimeEntries or trust ledgers.
• Encryption: use Access's built-in "Encrypt with Password" on the database file, and make sure the server share itself sits behind full-disk encryption (BitLocker) and a real backup policy.
• Audit trail: add `CreatedBy`, `ModifiedBy`, and `ModifiedDate` fields to sensitive tables, and log changes to deadlines and time entries in a dedicated `AuditLog` table via each form's `BeforeUpdate` event.
• Backups: automate nightly, versioned backups of the back-end file to a location that is not a synced cloud folder—see the OneDrive/Dropbox warning above.
• Trust accounting (IOLTA): be honest about the risk here. Trust accounting rules generally require three-way reconciliation with no tolerance for drift. Many firms keep matter, conflict, and time data in Access and run the actual trust ledger in dedicated accounting software, syncing balances rather than rebuilding a compliance-grade ledger from scratch in VBA.

When Your Firm Outgrows Access: The Migration Path

Two hard numbers to watch: Access/Jet database files cap out at 2GB, and the realistic concurrent-user ceiling is 15–20 people before locking and performance start to degrade. Neither means Access "failed"—it means the firm grew past what a file-based database is designed for.

Two common paths from there:

1. Upsize the back end to SQL Server Express or Azure SQL, and keep the familiar Access front end (forms, reports, VBA) connected over ODBC linked tables. This is the least disruptive path—staff keep the interface they already know, but the data engine gets real concurrency, size limits in the terabytes, and proper backup/replication.
2. Migrate fully to a SaaS practice platform once client portals, mobile intake, or LEDES e-billing become non-negotiable. At that point the value of Access's customization is usually outweighed by the built-in compliance and integration work a dedicated platform has already done.

Either way, plan the migration before you're forced into it by a corrupted 1.9GB file on a Monday morning.

When to Bring in a Developer / Upgrade Your System

Stay DIY when one person owns the file, the matter list is small, and a bad weekend experiment won't cost a filing deadline.

Bring in a developer when attorneys and staff must edit together daily, conflict and deadline logic needs to be trustworthy, or you're migrating years of history off Excel or Word and cannot afford to lose it. Start with Access database design and development or Access development.

Plan a practice-platform upgrade when clients need portals, you need deep trust accounting or LEDES, or concurrent users have outgrown even a well-split Access app. Some firms deliberately keep Access for internal matter and conflict tracking while SaaS handles client-facing pieces—just avoid two conflicting sources of truth for the same matter.

Related case study: Law Firm Time Billing.

Frequently Asked Questions

Next Steps

Map clients → matters → conflicts → deadlines → time on paper, then decide whether you're building a focused Access system or evaluating practice software. Start with legal solutions and the law firm time billing case study. Want it built correctly the first time—conflict checks and all? Contact us for a free consultation.