LegalOps

LegalOps (legal operations) is the discipline of running a legal department as a service operation. Lawyers decide legal questions; legal operations makes sure the right questions reach the right lawyer quickly, that routine work (a standard NDA, a low-risk renewal) does not need a lawyer at all, that law firms and other providers are chosen and paid on evidence, and that the department can say what it spends, what it delivers and how long it takes.

The Association of Corporate Counsel (ACC) puts it in one line: “Legal operations activities focus on optimizing legal services for corporations”, using business fundamentals, processes, data and technology.^[1] The Corporate Legal Operations Consortium (CLOC) describes legal ops professionals as “the chief operating officers of the legal team”.^[2]

This page is written for beginners, legal operations managers, general counsel and in-house lawyers, the engineers who build legal systems, and finance and procurement partners. Sources were last verified on 2026-10-23.

The practice is established; the one-word label “LegalOps” is not anyone’s official term. The two bodies that shape the field write “legal operations” or “legal ops”:

• CLOC, a not-for-profit member community, publishes the Core 12, its reference model for legal operations, and a Core 12 Maturity Assessment Playbook with four stages: Reactive, Emerging, Developing and Leading.^[3][4] CLOC’s own timeline dates its founding to 2015, its first institute (San Francisco) to 2016, the Core 12’s release to 2019 and the playbook to 2024.^[5] The twelve names have changed since at least March 2020, when a CLOC post listed, for example, “Vendor Management”, “Data Analytics” and “Litigation Support & IP Management”, while today’s page lists “Firm & Vendor Management”, “Business Intelligence” and “Practice Operations”.^[6][3]
• ACC publishes the Legal Operations Maturity Model 2.0 (the PDF is dated 2020), which assesses 14 functions at three stages, early, intermediate and advanced; the first model appeared in 2017.^[1]
• A certification is coming, not here yet. CLOC announces the Legal Operations Certified Professional (LOCP) for experienced practitioners (eligibility includes three or more years in legal operations); the first candidates sit the exam in May 2027 (as announced in October 2026; check CLOC for the current status).^[7]

The function also exists in law firms and government legal services, often under other names (practice management, pricing, legal project management). CLOC opened its membership to “the entire legal ecosystem” in 2021.^[5] This page centres on the in-house department, which is where both reference models were written; most of the practices transfer.

• Not legal advice. Legal operations staff are often not lawyers (CLOC lists backgrounds in finance, marketing, data analytics and learning).^[2] They design intake, templates and workflows; a lawyer owns every legal judgement. Whether a non-lawyer giving legal advice is unlawful depends on the jurisdiction, so draw the line by policy, not by habit.
• Not procurement. Buying legal services uses procurement disciplines, but sourcing strategy and purchase-to-pay belong to ProcurementOps. LegalOps owns the legal side: counsel selection criteria, billing guidelines, matter budgets and the contract terms Legal will accept.
• Not compliance. Proving that obligations are met (control evidence, audits) is ComplianceOps; LegalOps runs the department that interprets the obligations and negotiates the contracts that create them.
• Not a software purchase. Buying a contract lifecycle management (CLM) or e-billing system without intake data, templates and owners is, in this page’s reading, a frequent way to spend money on legal operations without improving them (see anti-patterns).
• Not cost-cutting only. CLOC notes that general counsel were originally focused on risk management and reducing outside counsel costs, and that the role has since widened to strategy, workforce and service-delivery design.^[2]

Without an operating model, an in-house legal team shows a familiar set of symptoms:

• Invisible demand. Requests arrive by email, chat and corridor conversation. Nobody knows how many there are, which business unit sends the most, or how long anything waits. Lawyers spend senior time on work that a template could do.
• Contract friction. Sales waits on Legal for a standard NDA; nobody can find the signed version of a supplier agreement; a renewal auto-extends because no one tracked the notice date. The ACC model describes this early stage plainly: contracts in multiple locations, ad hoc legal review, no automated date or renewal follow-up.^[1]
• Unmanaged external spend. Law firms are chosen by whoever knows a partner, invoices arrive as PDFs, and the first sign that a matter is over budget is the quarter-end accrual.
• Defensibility gaps. A dispute arrives, and the company cannot show when it started preserving data, who was told, or whether chat messages kept deleting. Courts in several jurisdictions expect reasonable preservation steps (see legal holds).

LegalOps exists to turn those symptoms into managed flows: demand that is counted and routed, contracts that move through a known lifecycle, spend that is planned and checked, and preservation that leaves evidence.

Corporate legal departments managed budgets and law firms long before anyone used the label. What changed in the 2010s was the emergence of a professional community and shared reference models: besides the milestones above, CLOC records 1,800 attendees at its 2017 Las Vegas institute and expansion into Europe and Asia-Pacific in 2018.^[5] ACC’s interest groups crowd-sourced the first maturity model in 2017 and version 2.0 in 2020 (with “well over a hundred company representatives”).^[1]

The data standards that legal operations depends on are older. The American Bar Association’s UTBMS litigation code set (Uniform Task Based Management System) dates from 1997,^[9] and the LEDES Oversight Committee publishes the LEDES 98B invoice format, last revised in 2014.^[10] The e-discovery community’s Electronic Discovery Reference Model (EDRM) has existed for years; its 2.0 version was released on 2026-09-01.^[11]

The forces at work now (as of October 2026) are professionalisation and generative AI; see advanced topics.

Mental model: a service desk with three ledgers. Think of legal operations as a service desk (requests in, routed, worked, closed) that keeps three ledgers: a contract ledger (what we have promised and when it ends), a matter-and-spend ledger (what we are working on, with whom, at what cost), and a preservation ledger (what we must not delete, and who has been told). Every practice on this page creates, updates or reads one of those ledgers.

flowchart TB
  BIZ["Business teams (sales, HR, product)"] -->|requests| LO
  subgraph LO["LegalOps (this page)"]
    direction LR
    IN["Intake and triage"] --> CLM["Contract lifecycle"]
    IN --> MAT["Matters, counsel, spend"]
    IN --> HOLD["Legal holds, e-discovery"]
  end
  LO -->|"supplier buys, PO, payment"| PROC["ProcurementOps"]
  LO -->|"obligations to evidence"| COMP["ComplianceOps"]
  LO -->|"privacy questions, DPAs"| PRIV["PrivacyOps"]
  RESP["ResponseOps (incidents)"] -->|"privilege, regulators"| LO
  PEOP["PeopleOps (employees)"] -->|"employment questions"| LO
  LO -->|"templates, know-how"| KNOW["KnowledgeOps"]
  classDef core fill:#e8f3f2,stroke:#16756f,color:#122029
  classDef neutral fill:#f1f4f6,stroke:#5b7a87,color:#122029
  class IN,CLM,MAT,HOLD core
  class BIZ,PROC,COMP,PRIV,RESP,PEOP,KNOW neutral

Mission. Deliver legal service that the business can predict and the company can defend, at a cost that matches the risk.

1. Demand is data. Every request enters through one front door and becomes a record with a type, requester, risk and outcome. You cannot staff, budget or automate work you have not counted.
2. Right work, right resource. CLOC’s “Service Delivery Models” competency is headed “Match the right work to the right resource”.^[3] Self-service for the standard, legal professionals for the structured, lawyers for judgement, providers for volume or specialism.
3. Standardise before you automate. A template, a playbook and a signature policy come before a CLM rollout.
4. Lawyers own judgement; operations owns the system. Ops people never quietly decide a legal question; lawyers never become the only people who know where a contract is.
5. Spend follows plans. Every external matter has a budget, an engagement letter and billing guidelines before work starts.
6. Defensibility by design. Preservation, privilege and retention are built into the workflow, with evidence, not reconstructed when a dispute starts.
7. Measure service, not activity. Cycle time, first-response time, self-service rate and spend against budget matter more than “contracts reviewed”.

Non-goals. Replacing lawyers; minimising legal spend regardless of outcome; collecting data that nobody acts on.

The two published models cover similar ground with different cuts. Use either as a checklist; neither is a standard you are audited against.

The mapping is this page’s reading; the bodies do not publish a crosswalk. Notice that ACC names contract management and e-discovery as functions of their own, which matches where most operational work and risk sit. This page therefore teaches four operational flows (intake, contracts, counsel and spend, holds and e-discovery) on top of three enabling capabilities (data, technology, people and knowledge).

A RACI for the recurring decisions (R = responsible, A = accountable, C = consulted, I = informed):

The rule to remember: a lawyer is accountable for every legal judgement, and LegalOps is accountable for the system that delivers it.

Every matter, whatever its type, moves through the same five stages. The stages are this page’s synthesis of the reference models.

1. Request. Captured through intake with type, requester, deadline, value and risk indicators.
2. Triage and route. Self-service, template path, legal professional, lawyer, or external provider; conflicts and privilege considered at this point (for example, whether an investigation should be run at counsel’s direction).
3. Work. Drafting, negotiation, advice, litigation steps; budgets tracked; holds issued when litigation is anticipated.
4. Close. Executed contract stored with metadata, matter closed with outcome and final spend, holds released only when the duty ends.^[13]
5. Learn. Clause fall-backs that were always conceded become playbook updates; repeated questions become self-service answers; firm performance feeds the next panel review.

Escalation paths must be written down: an urgent request outside hours, a contract over signature authority, a matter exceeding budget by more than an agreed threshold, a custodian who does not acknowledge a hold.

Legal operations is an organisational architecture with a thin layer of systems underneath it. The diagram shows the logical components; one product may cover several boxes, and a small team can run most of them on a ticketing tool, a document store and a spreadsheet.

flowchart TB
  subgraph FRONT["1. Front door"]
    FORM["Intake form"] --> TRI["Triage queue"]
    FORM --> SELF["Self-service"]
  end
  subgraph WORK["2. Work systems"]
    CLMS["CLM"]
    MMS["Matters, e-billing"]
    LH["Holds, e-discovery"]
  end
  subgraph BASE["3. Foundations"]
    DMS["Documents, knowledge"]
    ID["Identity, retention"]
    DATA["Reporting"]
  end
  TRI --> CLMS
  TRI --> MMS
  TRI --> LH
  CLMS --> DMS
  MMS --> DATA
  LH --> ID
  MMS --> FIN["Finance, procurement, ERP"]
  CLMS --> FIN
  classDef core fill:#e8f3f2,stroke:#16756f,color:#122029
  classDef neutral fill:#f1f4f6,stroke:#5b7a87,color:#122029
  class FORM,TRI,SELF,CLMS,MMS,LH core
  class DMS,ID,DATA,FIN neutral

Component responsibilities and trust boundaries.

Alternatives and trade-offs. An all-in-one legal platform reduces integration work but concentrates lock-in; best-of-breed tools fit better but need an integration owner. Building intake on the company’s existing service-desk tool is cheap and familiar to requesters but rarely handles contract metadata well. Whatever you choose, decide early where the contract record of truth lives and which system holds matter numbers that Finance uses for accruals.

The flow below follows a request for a customer contract. The happy path takes the standard route; the exception paths show where work leaves the standard route.

flowchart TB
  A["Requester submits intake form"] --> B{"Standard template and within playbook?"}
  B -->|yes| C["Self-service or contract manager drafts"]
  B -->|no| D["Routed to lawyer by type and risk"]
  C --> E{"Counterparty edits within fall-backs?"}
  E -->|yes| F["Approval per signature matrix"]
  E -->|no| D
  D --> G{"Deviation acceptable?"}
  G -->|"yes, with approvals"| F
  G -->|no| H["Escalate to GC or business owner; walk away or re-scope"]
  F --> I["E-signature and repository with metadata"]
  I --> J["Obligations and renewal dates tracked"]
  J --> K["Learn: update playbook if fall-back is always conceded"]
  classDef core fill:#e8f3f2,stroke:#16756f,color:#122029
  classDef decision fill:#fdf3e3,stroke:#c9800f,color:#122029
  classDef risk fill:#fbeceb,stroke:#b4332b,color:#122029
  classDef neutral fill:#f1f4f6,stroke:#5b7a87,color:#122029
  class A,C,F,I,J,K core
  class B,E,G decision
  class D neutral
  class H risk

Exception paths worth designing up front:

• Paper from the other side. The counterparty insists on its own template: route to a lawyer, but give the lawyer a clause checklist mapped to your playbook so review is comparable.
• Over signature authority. The contract value exceeds the requester’s authority: the workflow must block signature, not just warn. GitLab’s public handbook, for example, keeps an Authorization Matrix that “designates who is authorized to sign legal documents”.^[14]
• Urgent deals at quarter end. Define a published cut-off and an urgent lane with a named approver; otherwise every request becomes urgent.
• Sensitive requests. Employee investigations, whistle-blowing, regulator contact and security incidents skip the shared queue and go straight to a named lawyer.

Four flows carry most of the operational load. Each playbook below lists the steps, the owner, the acceptance criteria and the most common variant.

Why first. The ACC model treats a “Legal service request intake and triage function directing work to the appropriate resource” as an intermediate-stage capability,^[1] and it is the cheapest way to get data on everything else.

1. One front door. A form (in your service desk, CLM or a simple form tool) with no more than ten fields. Email to a shared address can stay, but someone converts every email into a record.
2. Request types. Start with eight to twelve types (NDA, sales contract, supplier contract, DPA, employment question, marketing review, dispute or claim, regulatory question, corporate/governance, other). Retire “other” when it exceeds 10% of volume.
3. Routing matrix. For each type: default route, risk triggers that escalate, and a service level for first response.
4. Sensitive lane. A separate, restricted route for investigations and anything an employee would not want a shared queue to see.
5. Close codes. Record the outcome (self-served, completed, withdrawn, referred to outside counsel) so the data shows where work really went.

Acceptance criteria. 90% of requests are records, not inbox items; every record has a type and an owner within one business day; the sensitive lane has been tested with a mock request.

Variant: the public handbook model. GitLab’s legal team publishes its intake channels in its public handbook: a company-wide (non-private) #legal chat channel for quick process questions “that do not require legal advice”, a legal case in Salesforce for most customer-specific questions, issue templates in a Legal and Compliance project for other deliverables, and an email address for sensitive or confidential matters.^[14] The design choice worth copying is that channels are separated by sensitivity, not by team, and that the open channel carries a warning: GitLab states that inquiries there are “visible to the entire company”.^[14]

flowchart TB
  R["Request"] --> D["Draft from template"]
  D --> N["Negotiate with playbook"]
  N --> AP["Approve per authority"]
  AP --> S["Sign"]
  S --> ST["Store with metadata"]
  ST --> O["Track obligations"]
  O --> RN{"Renew, amend or end?"}
  RN -->|renew or amend| N
  RN -->|end| X["Expire and retain per schedule"]
  ST -.->|"clause data"| P["Playbook and template updates"]
  P -.-> D
  classDef core fill:#e8f3f2,stroke:#16756f,color:#122029
  classDef decision fill:#fdf3e3,stroke:#c9800f,color:#122029
  classDef neutral fill:#f1f4f6,stroke:#5b7a87,color:#122029
  class R,D,N,AP,S,ST,O core
  class RN decision
  class X,P neutral

The ACC model describes the intermediate stage as a CLM tool with standard workflows and e-signatures, a central repository, “clearly defined corporate ownership of contracts”, templates and clause libraries, obligation tracking and expiration alerts, and lawyer review focused on exceptions; at the advanced stage, standardisation and playbooks “allow extensive contract creation/execution with no legal department involvement”.^[1]

Steps.

1. Inventory. Find where signed contracts live today; count them by type; pick the top three types by volume.
2. Templates. One current template per type, owned by a named lawyer, versioned, with a change log.
3. Playbook. For each negotiable clause: preferred position, acceptable fall-backs, walk-away point, who may approve each.
4. Signature authority. A matrix by contract type and value; e-signature configured so only authorised signers can sign.
5. Repository and metadata. Minimum fields: parties, type, owner, effective date, term, renewal mechanism, notice period, value, governing law, data processing (yes/no), link to the signed PDF.
6. Obligations and renewals. Alerts to the business owner (not only to Legal) at notice-date minus 60 and minus 30 days. The CLM holds the dates and notice periods; for supplier contracts, ProcurementOps runs the renewal or re-tender decision and LegalOps reviews any changed terms.
7. Learn. Quarterly, review which fall-backs were used most and either move them into the template or harden the position.

Acceptance criteria. For the top three types: template and playbook published, 100% of new contracts stored with the minimum metadata, renewal alerts tested on a sample.

Why it matters, carefully stated. World Commerce & Contracting (WorldCC) says its research shows “the average business loses almost 9% of value annually through poor contract management”, with best performers losing about 3%; the same page also gives 8.6%, and it does not publish its method there.^[19] Treat such figures as an association’s estimate that motivates measurement in your own company, not as a benchmark.

The ACC model’s intermediate stage includes billing guidelines “incorporated into e-billing/matter management systems and enforced through invoice review”, some alternative fee arrangements, and key performance indicators for external resources; the advanced stage has centralised outside counsel and vendor management with data-based selection and pricing.^[1]

1. Panel. A short list of preferred firms per practice area, with agreed rates by timekeeper class and a rate-increase policy.
2. Outside counsel guidelines. Staffing rules, rate caps, billing increments, what is not billable (for example internal training, routine administrative work), expense policy, budget and reporting duties, data security and confidentiality duties.
3. Engagement and budget. Every matter opens with an engagement letter, a matter number and a phased budget; for litigation use the UTBMS phases L100–L500 (case assessment, pre-trial pleadings and motions, discovery, trial preparation and trial, appeal) so budget and invoices use the same structure.^[9]
4. Structured invoices. Require LEDES submissions. LEDES 98B is an ASCII, pipe-delimited format with 24 fields per line;^[10] UTBMS task, activity and expense codes classify each line (for example A103 Draft/revise, E110 Out-of-town travel).^[20]
5. Review. Automated rules catch arithmetic, rate caps, missing codes and disallowed expenses; a lawyer reviews substance (was the work needed, was it staffed sensibly). See Lab 2.
6. Accruals and forecasts. Monthly, firms report work in progress; Finance books accruals per matter.
7. Performance review. After significant matters and annually: outcome, budget accuracy, responsiveness, staffing, guideline compliance.

sequenceDiagram
  participant Firm
  participant EB as E-billing
  participant Ops as LegalOps
  participant Law as Lawyer
  participant AP
  Firm->>EB: LEDES invoice
  EB->>EB: Rules check
  EB->>Firm: Format rejects
  EB->>Ops: Exceptions
  Ops->>Law: Substance query
  Law->>Ops: Approve or reduce
  Ops->>EB: Adjust with reasons
  EB->>AP: Approved amount
  EB->>Firm: Adjustment notice

Alternative fee arrangements. Fixed fees per phase, capped fees, portfolio fees and success components move risk to the firm and reward efficiency, but only work when scope is well defined and both sides track it. Start with repeatable matters (routine employment claims, trademark filings) where you have historical cost data.

This is the flow where an operations miss becomes legal exposure, so it is described in more detail.

When the duty starts. The Sedona Conference (a US non-profit that publishes non-binding consensus commentaries) says that when an organisation reasonably anticipates litigation, as initiator or target, it has a duty to take reasonable actions to preserve relevant paper, ESI and tangible items, and that the same principle applies to reasonably anticipated investigations.^[13]

What courts expect (jurisdiction-specific, as of October 2026, not legal advice).

• United States, federal courts. Under Federal Rule of Civil Procedure 37(e), if ESI that should have been preserved is lost because a party failed to take reasonable steps and cannot be restored or replaced, the court may order measures no greater than necessary to cure prejudice; the harshest measures (an adverse-inference instruction, dismissal or default) require a finding of intent to deprive. The current text took effect on 1 December 2015.^[21] Discovery itself is limited to matter that is relevant and “proportional to the needs of the case” (Rule 26(b)(1)).^[22]
• England and Wales, Business and Property Courts. Practice Direction 57AD places a duty on a person who knows it is or may become a party to take reasonable steps to preserve documents in its control (paragraph 3.1(1)). Paragraph 4.2 says this includes suspending relevant deletion or destruction processes; sending written notification to relevant employees and former employees “where there are reasonable grounds for believing that the employee or former employee may be in possession of disclosable documents which are not also in the party’s possession”; and taking reasonable steps so agents or third parties do not delete documents.^[23] So a departed employee’s company mailbox is covered by the duty to suspend deletion; the notification duty is about documents the person holds personally (home devices, personal accounts).

The process, mapped to Sedona’s twelve guidelines.^[13]

1. Policy, trigger and decide (Guidelines 1–5). A written hold policy, consistently followed (Guideline 2), and a reporting route that sends possible-dispute signals (demand letters, regulator contact, threatened claims) to a responsible lawyer (Guideline 3), who decides in good faith whether litigation is reasonably anticipated and records the decision and its date. Sedona presents the policy and the reporting procedure as factors that may demonstrate reasonableness and good faith.
2. Scope (Guidelines 6–7). Identify custodians and data stewards, systems, date range; scope is proportionate to the issues, accessibility, probative value and burden.
3. Notify (Guideline 8). Send a notice that explains what to keep and how, names a contact for questions, requires acknowledgement, addresses auto-delete features that must be suspended, and is followed by periodic reminders.
4. Preserve at source. IT suspends deletion for the custodians’ mail, chat and file stores and preserves accounts of departing or departed custodians; third parties holding data are notified where needed. A notice alone does not stop an automated deletion job, which is why Guideline 8 names auto-delete features and PD 57AD 4.2(1) names deletion processes.
5. Monitor and document (Guidelines 9–10). Sedona says compliance “should be regularly monitored” and that an organisation “should consider documenting” the procedure: track acknowledgements, escalate non-responders, record every step.
6. Collect, process, review, produce. Coordinate providers through the EDRM phases (below).
7. Release (Guideline 11). When the duty ends, release the hold so normal retention resumes, and tell custodians.
8. Cross-border (Guideline 12). Outside the US, check local data-protection law before collecting or transferring data.

flowchart TB
  T["Trigger: claim, demand, regulator contact"] --> DEC{"Litigation reasonably anticipated?"}
  DEC -->|no| LOG["Record decision and reasons"]
  DEC -->|yes| SC["Scope custodians, systems, dates"]
  SC --> NT["Send notice; IT suspends auto-delete"]
  NT --> ACK{"Acknowledged within policy?"}
  ACK -->|yes| MON["Monitor; periodic reminders"]
  ACK -->|no| ESC["Escalate to manager; preserve at source"]
  ESC --> MON
  MON --> END{"Duty ended?"}
  END -->|no| MON
  END -->|yes| REL["Release hold; resume retention"]
  classDef core fill:#e8f3f2,stroke:#16756f,color:#122029
  classDef decision fill:#fdf3e3,stroke:#c9800f,color:#122029
  classDef risk fill:#fbeceb,stroke:#b4332b,color:#122029
  classDef neutral fill:#f1f4f6,stroke:#5b7a87,color:#122029
  class SC,NT,MON,REL core
  class DEC,ACK,END decision
  class ESC risk
  class T,LOG neutral

E-discovery phases. EDRM 2.0 (released 2026-09-01) names nine phases: Analysis, Identification, Preservation, Collection, Processing, Review, Production, Presentation and Disposition. It groups identification through processing as “Data Acquisition”, places information governance underneath the model, adds Disposition as a core phase, and stresses that the model is “a conceptual view of the eDiscovery process, not a literal or linear workflow”.^[11] LegalOps typically owns provider selection, budgets, the hold process and the hand-offs with IT; counsel owns scope negotiations, privilege calls and production decisions. The ACC model’s intermediate stage includes standardised processes for identification, collection and preservation, “Legal hold system”, and “specific discovery expense codes by discovery vendors and task codes by firms”.^[1]

This flow is short here because neighbouring pages own the method. Templates and clause libraries are a knowledge product: run them with an owner, a version, a review date and a single authoritative location, as KnowledgeOps describes. Retention schedules and records management are information governance, which CLOC lists as a Core 12 competency;^[3] the legal operations job is to make sure the retention schedule and the legal hold process talk to each other, so that a hold always overrides scheduled deletion (Practice Direction 57AD says so explicitly for England and Wales, paragraph 4.1).^[23]

Separate what binds you from what helps you.

Tool categories first; brands change faster than jobs to be done. CLOC runs a Solutions Directory for its members,^[25] and ACC’s model describes capabilities rather than products.

Selection discipline. Write the process first, then run a structured demonstration against your own top three request types and a sample of your own contracts, with legal, finance, procurement, IT and security in the room. Check data export, identity integration, data residency, and what happens to AI features’ inputs (training, retention) before signing.

Automation in legal operations is mostly unglamorous and high-value: routing rules, template assembly, e-billing rules, renewal alerts, hold reminders. Generative AI adds summarisation, first-draft clause comparison, metadata extraction and question answering over templates. Two documented signals set the boundaries, and a third point applies to in-house teams.

• Courts expect lawyers to verify. In Mata v. Avianca (US District Court, S.D.N.Y., opinion of 22 June 2023), Judge Castel wrote that “there is nothing inherently improper about using a reliable artificial intelligence tool for assistance. But existing rules impose a gatekeeping role on attorneys to ensure the accuracy of their filings.” The lawyers had filed non-existent opinions generated by ChatGPT and stood by them after the court questioned them. The sanctions rested on a finding of bad faith “based upon acts of conscious avoidance and false and misleading statements to the Court”, not on the use of AI as such; the court ordered letters to the client and to each judge falsely named as an author, and a $5,000 penalty.^[26]
• Bar guidance (US). ABA Formal Opinion 512 (29 July 2024) addresses generative AI. As summarised in the National Conference of Bar Examiners’ journal, it says informed client consent is required before inputting information relating to a representation into many self-learning tools (boilerplate consent is not enough), that the verification needed depends on the tool and the task, that managerial lawyers must establish clear policies on permissible use, and that hourly billers may bill only time actually spent.^[27] ABA opinions guide but do not bind by themselves; state rules and opinions apply.
• For an in-house team, the client is the organisation. ABA Model Rule 1.13(a) says a lawyer employed or retained by an organisation “represents the organization acting through its duly authorized constituents”.^[28] So the consent question in Opinion 512 becomes, in practice, an internal governance decision: who in the company may authorise which data to go into which tool. Counsel confirms how the local rules apply; LegalOps records the approval. When outside counsel use AI on your matters, the question moves into the outside counsel guidelines (see Artefact 4).

What this means for LegalOps. Maintain an approved-tool list with data-handling terms; route client or company confidential data only to tools whose terms prohibit training on it; log which outputs a lawyer reviewed; never let generated text reach a court, regulator or counterparty without a named reviewer. Measure AI features by the same service metrics as any other change (cycle time, rework, error rate), not by usage counts.

The reference implementation for a business function is a set of artefacts, not code. The ones below fit a company of a few hundred to a few thousand people with a legal team of three to fifteen; adapt fields to your jurisdictions. All values are illustrative.

Example status: syntax-checked (YAML), not executed; field names are illustrative and tool-neutral.

form: legal-request
version: 2026-10
fields:
  - id: request_type
    label: What do you need?
    type: select
    options: [NDA, Sales contract, Supplier contract, Data processing agreement,
              Employment question, Marketing review, Dispute or claim,
              Regulatory question, Corporate or governance, Other]
    required: true
  - id: counterparty
    label: Other party (legal name)
    type: text
    required_when: {request_type: [NDA, Sales contract, Supplier contract,
                                   Data processing agreement]}
  - id: value
    label: Total contract value (USD, whole term)
    type: number
  - id: deadline
    label: Business deadline and why
    type: text
    required: true
  - id: their_paper
    label: Is the other party insisting on its own template?
    type: boolean
  - id: personal_data
    label: Will personal data be shared or processed?
    type: select
    options: ["Yes", "No", "Not sure"]
  - id: sensitive
    label: Does this concern an employee complaint, investigation or regulator?
    type: boolean
    help: If yes, the request goes to a restricted queue visible only to named lawyers.
  - id: attachments
    label: Drafts, prior agreements, correspondence
    type: files
routing_rules_ref: legal-routing-matrix v2026-10

Targets are illustrative starting points to replace with your own baseline after a month of data (see metrics).

This is a sell-side playbook (our fees, our renewals); a buy-side playbook inverts several positions. Governing law (which law applies) and forum (where disputes are decided and judgments enforced) are separate clauses with separate fall-backs.

Example status: plain text template; values are illustrative.

OUTSIDE COUNSEL GUIDELINES (excerpt) - version 2026-10
1. Engagement   No work before a signed engagement letter and a matter number.
2. Staffing     Named team per matter; changes need the matter lawyer's approval.
3. Rates        Agreed rates per timekeeper class; no increase without 90 days'
                written notice and approval. Hourly work: bill actual time only.
4. Budget       Phased budget (UTBMS L100-L500 for litigation) within 30 days;
                notify us before exceeding any phase by 10%.
5. Invoices     Monthly, LEDES 98B, one matter per invoice, UTBMS task and activity
                codes on every fee line, 0.1-hour increments, one task per entry.
6. Not billable Conflict checks, file opening, training, internal conferences of more
                than two timekeepers without approval, invoice preparation.
7. Expenses     At cost; no meals unless travelling overnight; no first-class travel.
8. Reporting    Case assessment within 60 days; monthly accrual of work in progress.
9. Security     Our data only in systems that meet our security schedule; report
                any security incident affecting our data within 24 hours.
10. AI use      Tell us which generative AI tools you use on our matters; none of
                our data in tools that train on inputs or keep them beyond the
                matter; a lawyer verifies every output; no charge for time spent
                learning a tool.

The AI clause reflects the billing and confidentiality points summarised in Automation and AI; the exact terms are a policy choice for your GC.^[27]

Three labs on synthetic data only: Python 3.8 or later and a bash shell, standard library only, no accounts, no cost. Each lab was run on 2026-10-23 exactly as printed (Python 3.8.10, Ubuntu Linux); expected outputs are copied from those runs.

Objective. Compute first-response attainment, the no-lawyer-touch rate, median cycle time per contract type and the age of open requests, and see why medians and per-type views matter. Prerequisites. Python 3.8+ and bash. Time. 20 minutes. Risk. None (synthetic data).

1. Create the folder and an intake log of twelve requests.

Example status: verified by execution on 2026-10-23 (bash, Linux).

mkdir -p ~/legalops-labs/lab1 && cd ~/legalops-labs/lab1
cat > requests.csv <<'EOF'
id,type,received,first_response,executed,path
R01,NDA,2026-09-01,2026-09-01,2026-09-01,self-service
R02,NDA,2026-09-02,2026-09-02,2026-09-03,self-service
R03,NDA,2026-09-03,2026-09-04,2026-09-08,legal
R04,MSA,2026-09-01,2026-09-02,2026-09-22,legal
R05,MSA,2026-09-04,2026-09-09,2026-10-02,legal
R06,DPA,2026-09-05,2026-09-08,2026-09-19,legal
R07,SOW,2026-09-08,2026-09-08,2026-09-10,template
R08,SOW,2026-09-09,2026-09-11,2026-09-15,template
R09,MSA,2026-09-15,2026-09-16,,legal
R10,NDA,2026-09-16,2026-09-16,2026-09-16,self-service
R11,Vendor,2026-09-17,2026-09-22,2026-10-06,legal
R12,DPA,2026-09-22,2026-09-23,,legal
EOF

2. Save the script as metrics.py.

Example status: verified by execution on 2026-10-23 (Python 3.8.10, standard library).

"""Contract-request metrics from an intake log (standard library only)."""
import csv
from collections import defaultdict
from datetime import date
from statistics import median

AS_OF = date(2026, 10, 9)        # date of the report
FIRST_RESPONSE_SLA_DAYS = 1      # promise: first response within 1 calendar day


def d(text):
    return date.fromisoformat(text) if text else None


with open("requests.csv", newline="") as f:
    rows = list(csv.DictReader(f))

cycle = defaultdict(list)
met_sla = 0
executed = 0
no_legal_touch = 0
open_items = []
for r in rows:
    received, first, done = d(r["received"]), d(r["first_response"]), d(r["executed"])
    if (first - received).days <= FIRST_RESPONSE_SLA_DAYS:
        met_sla += 1
    if done:
        executed += 1
        cycle[r["type"]].append((done - received).days)
        if r["path"] in ("self-service", "template"):
            no_legal_touch += 1
    else:
        open_items.append((r["id"], r["type"], (AS_OF - received).days))

print(f"Requests: {len(rows)}  executed: {executed}  open: {len(open_items)}")
print(f"First-response SLA met: {met_sla}/{len(rows)} = {met_sla / len(rows):.0%}")
print(f"Executed without lawyer negotiation: {no_legal_touch}/{executed}"
      f" = {no_legal_touch / executed:.0%}")
print("Median cycle time (calendar days, executed only):")
for kind in sorted(cycle):
    days = cycle[kind]
    print(f"  {kind:<7} n={len(days)}  median={median(days):>5.1f}  max={max(days)}")
print("Open requests by age (days since received):")
for rid, kind, age in sorted(open_items, key=lambda x: -x[2]):
    print(f"  {rid} {kind:<4} {age} days")

3. Run python3 metrics.py.

Expected output.

Requests: 12  executed: 10  open: 2
First-response SLA met: 8/12 = 67%
Executed without lawyer negotiation: 5/10 = 50%
Median cycle time (calendar days, executed only):
  DPA     n=1  median= 14.0  max=14
  MSA     n=2  median= 24.5  max=28
  NDA     n=4  median=  0.5  max=5
  SOW     n=2  median=  4.0  max=6
  Vendor  n=1  median= 19.0  max=19
Open requests by age (days since received):
  R09 MSA  24 days
  R12 DPA  17 days

Validation. By hand: first responses within one day are R01, R02, R03, R04, R07, R09, R10 and R12, so 8 of 12. NDAs took 0, 1, 5 and 0 days, median (0 + 1) ÷ 2 = 0.5. The mean NDA time (1.5 days) would hide that most NDAs close the same day while one stalled for 5: that stalled NDA (R03, routed to a lawyer) is the one to investigate.

Units. This lab counts days in calendar days for brevity; the routing matrix, scorecard and worked quarter state the first-response SLA in business days. Write the unit into each definition and never mix them (Lab 3 counts business days).

Troubleshooting. FileNotFoundError: run the script in the folder that contains requests.csv. ValueError from fromisoformat: a date is not in YYYY-MM-DD form.

Teardown. rm -rf ~/legalops-labs/lab1

Objective. Parse a LEDES 98B file (the field order follows the LEDES Oversight Committee’s sample file)^[10] and apply five billing-guideline rules: arithmetic, header total, missing UTBMS task code, disallowed expense code, rate cap; flag possible block billing for a human. Prerequisites. Lab 1 environment. Time. 30 minutes. Risk. None (synthetic invoice; the law-firm ID 00-0000000 is a placeholder).

1. Create the invoice file. Real files end each line with [] and usually a Windows line ending; this lab keeps the [].

Example status: verified by execution on 2026-10-23 (bash, Linux).

mkdir -p ~/legalops-labs/lab2 && cd ~/legalops-labs/lab2
H='INVOICE_DATE|INVOICE_NUMBER|CLIENT_ID|LAW_FIRM_MATTER_ID|INVOICE_TOTAL'
H="$H|BILLING_START_DATE|BILLING_END_DATE|INVOICE_DESCRIPTION|LINE_ITEM_NUMBER"
H="$H|EXP/FEE/INV_ADJ_TYPE|LINE_ITEM_NUMBER_OF_UNITS|LINE_ITEM_ADJUSTMENT_AMOUNT"
H="$H|LINE_ITEM_TOTAL|LINE_ITEM_DATE|LINE_ITEM_TASK_CODE|LINE_ITEM_EXPENSE_CODE"
H="$H|LINE_ITEM_ACTIVITY_CODE|TIMEKEEPER_ID|LINE_ITEM_DESCRIPTION|LAW_FIRM_ID"
H="$H|LINE_ITEM_UNIT_COST|TIMEKEEPER_NAME|TIMEKEEPER_CLASSIFICATION|CLIENT_MATTER_ID"
P='20260930|INV-0912|ACME01|7781|5448.50|20260901|20260930|Professional services'
# row <line number … description> <unit cost|timekeeper name|classification>
row() { echo "$P|$1|00-0000000|$2|LIT-2026-014[]"; }
{
  echo 'LEDES1998B[]'
  echo "$H[]"
  row '1|F|2.0|0|1300.00|20260903|L120||A104|TK1|Assess complaint and strategy' \
      '650|Partner, Pat|PARTNR'
  row '2|F|3.5|0|1575.00|20260905|L210||A103|TK3|Draft answer; venue research; call' \
      '450|Assoc, Ari|ASSOC'
  row '3|F|1.0|0|180.00|20260910|||A106|TK4|Telephone call with client' \
      '180|Para, Lee|PARALEGAL'
  row '4|F|0.5|0|325.00|20260912|L160||A107|TK1|Settlement call, opposing counsel' \
      '650|Partner, Pat|PARTNR'
  row '5|E|1|0|48.50|20260912||E111|||Working dinner' '48.50||'
  row '6|E|1|0|120.00|20260915||E101|||Copying of exhibits' '120.00||'
  row '7|F|2.0|0|900.00|20260918|L310||A103|TK3|Draft interrogatory responses' \
      '450|Assoc, Ari|ASSOC'
  row '8|F|1.5|0|1000.00|20260920|L330||A101|TK1|Prepare for deposition of CFO' \
      '650|Partner, Pat|PARTNR'
} > invoice.txt

2. Save the checker as check_invoice.py.

Example status: verified by execution on 2026-10-23 (Python 3.8.10, standard library).

"""Check a LEDES 1998B invoice against illustrative billing guidelines."""
RATE_CAPS = {"PARTNR": 650, "ASSOC": 400, "PARALEGAL": 180}  # hourly caps agreed
DISALLOWED_EXPENSES = {"E111": "meals not reimbursable"}


def money(x):
    return round(float(x), 2)


with open("invoice.txt", encoding="ascii") as f:
    lines = [ln.strip() for ln in f if ln.strip()]
assert all(ln.endswith("[]") for ln in lines), "every line must end with []"
lines = [ln[:-2] for ln in lines]
assert lines[0] == "LEDES1998B", "not a LEDES 1998B file"
rows = [ln.split("|") for ln in lines[1:]]
bad = [i for i, r in enumerate(rows, start=2) if len(r) != 24]
assert not bad, f"lines without exactly 24 fields: {bad}"
items = [dict(zip(rows[0], r)) for r in rows[1:]]

billed = approved = reduced = held = 0.0
for it in items:
    n, kind = it["LINE_ITEM_NUMBER"], it["EXP/FEE/INV_ADJ_TYPE"]
    units, rate = float(it["LINE_ITEM_NUMBER_OF_UNITS"]), money(it["LINE_ITEM_UNIT_COST"])
    adj, total = money(it["LINE_ITEM_ADJUSTMENT_AMOUNT"]), money(it["LINE_ITEM_TOTAL"])
    billed += total
    ok, notes = total, []
    if abs(units * rate + adj - total) > 0.005:
        ok, notes = 0.0, [f"HOLD {units} x {rate:.0f} + {adj:.0f} != {total:.2f}"]
    elif kind == "F" and not it["LINE_ITEM_TASK_CODE"]:
        ok, notes = 0.0, ["HOLD no UTBMS task code"]
    elif kind == "E" and it["LINE_ITEM_EXPENSE_CODE"] in DISALLOWED_EXPENSES:
        ok, notes = 0.0, ["REDUCE " + DISALLOWED_EXPENSES[it["LINE_ITEM_EXPENSE_CODE"]]]
    elif kind == "F":
        cap = RATE_CAPS.get(it["TIMEKEEPER_CLASSIFICATION"])
        if cap is not None and rate > cap:
            ok = round(units * cap + adj, 2)
            notes.append(f"REDUCE rate {rate:.0f} > cap {cap}")
        if ";" in it["LINE_ITEM_DESCRIPTION"] and units > 1.0:
            notes.append("REVIEW block billing?")
    if notes and notes[0].startswith("HOLD"):
        held += total
    else:
        reduced += total - ok
    approved += ok
    line = f"{n:>2} {kind} billed {total:>8.2f} ok {ok:>8.2f}  {'; '.join(notes)}"
    print(line.rstrip())

header_total = money(items[0]["INVOICE_TOTAL"])
print(f"Header total {header_total:.2f} vs sum of lines {billed:.2f}:",
      "OK" if abs(header_total - billed) < 0.005 else "MISMATCH")
print(f"Approved {approved:.2f}; held for correction {held:.2f}; reduced {reduced:.2f}")
decided = billed - held  # held lines come back later; leave them out of both sides
print(f"Reduction rate (final cuts / billed on decided lines): {reduced / decided:.2%}")

3. Run python3 check_invoice.py.

Expected output.

 1 F billed  1300.00 ok  1300.00
 2 F billed  1575.00 ok  1400.00  REDUCE rate 450 > cap 400; REVIEW block billing?
 3 F billed   180.00 ok     0.00  HOLD no UTBMS task code
 4 F billed   325.00 ok   325.00
 5 E billed    48.50 ok     0.00  REDUCE meals not reimbursable
 6 E billed   120.00 ok   120.00
 7 F billed   900.00 ok   800.00  REDUCE rate 450 > cap 400
 8 F billed  1000.00 ok     0.00  HOLD 1.5 x 650 + 0 != 1000.00
Header total 5448.50 vs sum of lines 5448.50: OK
Approved 3945.00; held for correction 1180.00; reduced 323.50
Reduction rate (final cuts / billed on decided lines): 7.58%

Validation. Line 2: 3.5 hours × the 400 cap = 1,400, so 175 is cut. Line 7: 2.0 × 400 = 800, 100 cut. Line 5: 48.50 meals disallowed. Final reductions 175 + 100 + 48.50 = 323.50. Lines 3 and 8 (1,180.00) are held, not reduced: the firm can correct and resubmit them, so they leave both sides of the ratio. Decided lines: 5,448.50 − 1,180.00 = 4,268.50, and 323.50 ÷ 4,268.50 = 7.58%, the definition used in metrics. Reporting held amounts as savings is a classic way to overstate e-billing value.

Troubleshooting. lines without exactly 24 fields: a missing or extra pipe; count the empty fields between ||. A rate-cap miss: check that TIMEKEEPER_CLASSIFICATION matches the keys in RATE_CAPS exactly.

Teardown. rm -rf ~/legalops-labs/lab2

Objective. Turn a custodian list into the evidence Sedona’s guidelines ask for: acknowledgements, escalation of non-responders, departed custodians whose data must be preserved at source, systems where auto-delete is still on, and the next reminder date.^[13] Prerequisites. Lab 1 environment. Time. 30 minutes. Risk. None (synthetic custodians).

1. Create the custodian list.

Example status: verified by execution on 2026-10-23 (bash, Linux).

mkdir -p ~/legalops-labs/lab3 && cd ~/legalops-labs/lab3
cat > custodians.csv <<'EOF'
custodian,role,notice_sent,acknowledged,systems,auto_delete_suspended,status
C01,Sales director,2026-10-01,2026-10-01,mail;chat;crm,yes,active
C02,Account executive,2026-10-01,2026-10-06,mail;chat,yes,active
C03,Solutions engineer,2026-10-01,,mail;chat;drive,no,active
C04,Former account executive,2026-10-01,,mail,no,departed
C05,Finance analyst,2026-10-02,2026-10-02,mail;erp,yes,active
C06,Product manager,2026-10-05,,mail;chat;drive,yes,active
EOF

2. Save the script as hold_report.py.

Example status: verified by execution on 2026-10-23 (Python 3.8.10, standard library).

"""Legal hold status report: acknowledgements, escalations, preservation gaps."""
import csv
from datetime import date, timedelta

HOLD_ISSUED = date(2026, 10, 1)
AS_OF = date(2026, 10, 12)
ACK_DUE_BUSINESS_DAYS = 5      # policy: acknowledge within 5 business days
REMINDER_EVERY_DAYS = 90       # policy: periodic reminder notices


def business_days(start, end):
    """Weekdays after start up to and including end (public holidays ignored)."""
    days, d = 0, start
    while d < end:
        d += timedelta(days=1)
        if d.weekday() < 5:
            days += 1
    return days


with open("custodians.csv", newline="") as f:
    rows = list(csv.DictReader(f))

acked = [r for r in rows if r["acknowledged"]]
print(f"Acknowledged: {len(acked)}/{len(rows)} = {len(acked) / len(rows):.0%}")
for r in rows:
    if r["acknowledged"]:
        continue
    sent = date.fromisoformat(r["notice_sent"])
    elapsed = business_days(sent, AS_OF)
    if r["status"] == "departed":
        print(f"{r['custodian']} DEPARTED: IT/data steward to preserve {r['systems']}")
    elif elapsed > ACK_DUE_BUSINESS_DAYS:
        print(f"{r['custodian']} OVERDUE {elapsed} business days: escalate to manager")
    else:
        print(f"{r['custodian']} pending ({elapsed}/{ACK_DUE_BUSINESS_DAYS} bus. days)")
for r in rows:
    if r["auto_delete_suspended"] != "yes":
        print(f"GAP {r['custodian']}: auto-delete still on for {r['systems']}")
print("Next reminder due:", HOLD_ISSUED + timedelta(days=REMINDER_EVERY_DAYS))

3. Run python3 hold_report.py.

Expected output.

Acknowledged: 3/6 = 50%
C03 OVERDUE 7 business days: escalate to manager
C04 DEPARTED: IT/data steward to preserve mail
C06 pending (5/5 bus. days)
GAP C03: auto-delete still on for mail;chat;drive
GAP C04: auto-delete still on for mail
Next reminder due: 2026-12-30

Validation. The hold went out on Thursday 1 October 2026. Business days to Monday 12 October: 2, 5, 6, 7, 8, 9 and 12 October = 7, so C03 is past the five-day policy. C06 received the notice on Monday 5 October and is exactly at five business days: pending, not overdue. C04 has left; a former employee cannot acknowledge, and the company mailbox is in the company’s own systems, so preservation must happen at source: suspend the deletion job. In US practice that is part of the “reasonable steps” FRCP 37(e) looks for and of Sedona’s Guidelines 6–8 (identify custodians and data stewards; address auto-delete).^[21][13] (For England and Wales, see the PD 57AD note under legal holds.) 90 days after 1 October is 30 December.

Troubleshooting. Holiday calendars are ignored; add a set of public holidays and skip them in business_days for your jurisdiction. If a custodian has several notices (re-issued holds), keep one row per notice.

Teardown. rm -rf ~/legalops-labs/lab3

Context. GitLab publishes its Legal and Corporate Affairs handbook. It names a “Strategy and Legal Operations” group that “promotes continued process improvement” including “procurement of the most suitable tools and technology”.^[14] Method. The channel design is described under intake and triage; an authorization matrix governs who may sign.^[14] Trade-offs. A company-wide channel scales answers to common questions and reduces repeat requests, but only works with the confidentiality warning GitLab gives. What is not documented. The handbook does not report cycle times or outcomes; treat it as a design example, not evidence of results. Success criteria to borrow. Share of requests arriving through the right channel; volume of process questions answered without a legal record.

Context. In In re Capital One Consumer Data Security Breach Litigation (E.D. Va.), the district court on 25 June 2020 affirmed a magistrate judge’s order requiring Capital One to produce a forensic report about its 2019 data breach. The only question before the court was whether the report was protected work product; it did not decide attorney–client privilege.^[29] Facts the court relied on. Capital One had a 2015 master services agreement and a January 2019 statement of work with the forensic firm for incident response, paid from a fund the company called “business critical” expenses. After the breach, a letter agreement through outside counsel covered essentially the same scope on the payment terms of the 2019 statement of work. The report was paid first from the retainer already held under that statement of work and then from Capital One’s cyber budget; those payments were later re-designated as legal expenses. The report went to about 50 employees, a governance mailbox, the board, four regulators and the company’s accountant. The court held that Capital One had not shown the report would not have been prepared in substantially similar form but for the prospect of litigation (the “because of” test); it contrasted a case where protection was granted because the pre-breach work was separate from the post-breach engagement.^[29]

The operations lesson (not legal advice). Privilege and work-product outcomes depend on facts that operations create: which contract governs the work, which budget pays for it, who receives the output. Re-labelling spend afterwards does not change those facts: the later re-designation to legal expenses did not prevent the order to produce. LegalOps should make sure counsel decides them before an incident (engagement templates, distribution rules, separate business and legal deliverables where counsel wants them), and that ResponseOps knows the playbook. Outcomes differ by court and jurisdiction; this is one district-court decision.

Context. A legal team wants an AI assistant to summarise counterparty edits against the playbook. Method. LegalOps writes the use policy (approved tools, no confidential inputs into tools that train on them, reviewer named for each output), pilots on NDAs and DPAs, and measures cycle time and rework against a control group. Why the guard rails. See Automation and AI. Success criteria. Median NDA cycle time falls without a rise in post-signature issues; 100% of AI-assisted outputs have a named reviewer. Pitfall. Measuring “prompts per week” instead of outcomes.

Context. A manufacturer uses 40 firms across 12 countries; invoices arrive as PDFs; accruals are guesses. Method. Map 24 months of spend by firm and matter type; choose two or three preferred firms per practice and region; require LEDES with UTBMS codes; introduce phased budgets and fixed fees for repeatable work; review firms annually against outcome, budget accuracy and guideline compliance. Trade-offs. Fewer firms give leverage and better data but can lose niche expertise and local relationships; keep an exception route. Success criteria. Share of external spend under preferred firms; budget accuracy per phase; time from month-end to accrual. Pitfall. Declaring “savings” from list-rate discounts while hours rise.

Measure the service the business receives, the money the department controls, and the risk it carries. Every measure needs a definition that two analysts would compute the same way.

Worked calculation (synthetic quarter). A legal department of 8 people received 1,240 requests in a quarter, of which 1,054 got a first response within one business day: 1,054 ÷ 1,240 = 85.0% attainment. It executed 600 contracts, 330 on the template or self-service path: 330 ÷ 600 = 55% no-lawyer-touch. External budget for the quarter was 1.20 million; actual was 1.32 million: (1.32 − 1.20) ÷ 1.20 = +10% over budget, of which one litigation matter accounts for 0.10 million (a discovery phase that ran 40% over its phase budget). Internal cost (salaries, benefits, tools) was 0.90 million, so the external share is 1.32 ÷ (1.32 + 0.90) = 59%. Invoices billed 1.35 million, of which 0.05 million was held for correction; final reductions were 0.03 million on the 1.30 million decided, so the reduction rate is 0.03 ÷ 1.30 = 2.3%. The interesting decision is not any single number: the discovery overrun plus a 59% external share suggests looking at the e-discovery provider model, not at hourly rates.

Target setting. Collect one month of baseline before setting targets; set targets per contract type and request type; publish the definitions with the targets. Review cadence: weekly for queue and cycle measures, monthly for spend, quarterly for the scorecard. Data limits: intake data is only as good as the share of work captured; a 60% capture rate makes every other measure suspect, so report capture first.

flowchart TB
  CAP["Capture: intake, CLM, e-billing, hold records"] --> DEF["Define: one formula per metric, per type"]
  DEF --> REV["Review: weekly queue, monthly spend, quarterly scorecard"]
  REV --> ACT["Act: re-route, change playbook, renegotiate, staff"]
  ACT --> CAP
  REV --> RISK{"Risk signal? overdue holds, budget overrun"}
  RISK -->|yes| ESC["Escalate to GC same week"]
  classDef core fill:#e8f3f2,stroke:#16756f,color:#122029
  classDef decision fill:#fdf3e3,stroke:#c9800f,color:#122029
  classDef risk fill:#fbeceb,stroke:#b4332b,color:#122029
  class CAP,DEF,REV,ACT core
  class RISK decision
  class ESC risk

• Privilege by design. Mark privileged content, keep advice memos out of shared business folders, and keep dashboards free of privileged text. Privilege and work-product rules differ between jurisdictions (for example on in-house counsel communications); counsel decides labels and distribution, operations enforces them. The Capital One decision, a work-product ruling, shows how distribution and engagement structure can matter in a US federal court (see Scenario 2).^[29]
• Least privilege in legal systems. Law firms see only their matters; restricted matter types (investigations, employee issues, M&A) are invisible to general users; administrator accounts are few and reviewed.
• Personal data. Contracts, matters and holds contain personal data; legal holds can conflict with deletion duties under data protection law, and Sedona’s Guideline 12 flags local data-protection law for holds outside the US.^[13] Work with PrivacyOps on retention, lawful basis and transfers.
• Vendor security. Law firms, e-discovery providers and legal-tech vendors hold some of the most sensitive data the company has; put security duties in the guidelines (see Artefact 4) and in contracts, and assess them like any critical supplier (RiskOps).
• AI tools. Apply the approved-tool list and named-reviewer rule from Automation and AI.
• Evidence retention. Keep hold notices, acknowledgements, scoping decisions and release notices for at least the life of the matter plus the period your counsel sets; they are your proof of reasonableness.

Cost drivers. External counsel (often a large share; check your own split with the internal/external mix metric), internal headcount, e-discovery (data volume × processing and hosting × review hours), technology subscriptions, and the hidden cost of business time lost waiting for Legal.

Unit economics that help decisions.

• Cost per contract by path: (lawyer hours × loaded internal rate + tool cost share) ÷ contracts, per path. If a template-path NDA costs a tenth of a lawyer-reviewed one, the template is worth maintaining.
• Cost per matter phase (UTBMS L100–L500), compared with the budget and with similar past matters.^[9]
• E-discovery cost per custodian and per gigabyte reviewed, tracked per matter; the biggest lever is scoping data down early, which EDRM 2.0 emphasises with its “left lean” towards early assessment and targeted scoping.^[11]

Capacity. Use intake data to model demand by type and month (for example, a quarter-end peak in sales contracts, if your data shows one) and decide which peaks to meet with self-service, with temporary contract managers, or with an alternative legal service provider.

Sustainability. For most legal departments the environmental footprint is small; the material sustainability issue is people: lawyers absorbing unplanned volume burn out. Track overtime proxies (requests per lawyer per week, weekend work) alongside the service metrics.

• Data quality checks: share of requests with type and owner; contracts missing renewal dates; invoices without UTBMS codes.
• Control tests: quarterly sample of ten executed contracts against the signature matrix; sample of five holds for complete evidence (scope decision, notices, acknowledgements, IT confirmation).
• Exception monitoring: matters over budget by more than 10%, contracts signed outside the CLM, firms invoicing outside the e-billing system.
• Feedback: a two-question satisfaction survey after closure, reviewed quarterly; complaints routed to the head of LegalOps.
• Internal audit: ask internal audit to include signature authority and legal hold evidence in its plan; it is cheaper to find gaps there than in litigation.

Situation. On 1 October 2026 a US company receives a demand letter from a former distributor alleging breach of contract. Counsel decides litigation is reasonably anticipated and issues a hold to six custodians. On 12 October the weekly hold report (Lab 3) shows that C04, an account executive who negotiated the distribution agreement, left the company on 25 September; the mailbox is still under the standard 30-day post-departure deletion rule.

Runbook.

1. Contain (same day). Ask IT to suspend deletion for C04’s mailbox and any chat and file stores now; confirm in writing with a timestamp. Check whether the device was wiped and whether backups exist.
2. Assess loss. Establish what, if anything, has already been deleted, from which systems and on what dates, and whether it can be restored or replaced from other sources (counterparties’ copies, other custodians, CRM records). Under US federal Rule 37(e), restorability and reasonableness matter.^[21]
3. Inform counsel. The matter lawyer decides whether and how to disclose any loss and how to describe the preservation steps; operations supplies the facts and the timeline, not conclusions.
4. Close the gap for this hold. Add the HR leaver feed to the hold tool so that any custodian on an active hold triggers preservation before account deletion; re-run the report.
5. Fix the system. Change the leaver process: before deprovisioning, check the hold register (an integration with PeopleOps and identity teams); test with a synthetic leaver.
6. Document. Record the trigger date, scoping decision, notices, the gap, containment time and the systemic fix. Sedona’s Guidelines 2–5 tie reasonableness and good faith to a followed policy, a reporting procedure and decisions judged when made; Guidelines 9–10 add monitoring and documentation. The record is how you show both.^[13]

Prevention measures. Hold scoping always includes recently departed staff; the leaver process checks the hold register; the weekly report lists departed custodians separately; auto-delete suspension is confirmed per system, not assumed.

• “Buy a CLM and the contracts will sort themselves out.” Without templates, playbooks and owners the tool digitises the mess. Do the process work first, then automate.
• “Every contract must be reviewed by a lawyer.” It feels safe, it queues the business behind Legal, and it spends judgement on routine paper. The ACC model’s advanced stage is the opposite: playbooks allow execution “with no legal department involvement” for standard work.^[1]
• “Invoice reductions are savings.” Cuts that firms recover in next month’s hours, or holds reported as savings, overstate value. Track final reductions and total matter cost.
• “LegalOps is a cost-cutting role.” See what LegalOps is not; a team measured only on cost will under-invest in intake and knowledge.
• “A legal hold is an email.” The email is one step; scoping, acknowledgements, IT preservation, reminders, leavers and release are where holds fail.^[13]
• “AI will replace review.” Courts expect lawyers to verify (Automation and AI); the realistic gain is faster first drafts and triage, with review retained.
• “We will add metrics later.” Without intake data from day one you will never have a baseline to show improvement.

Use a dedicated legal operations capability when two or more of these hold: the legal team has more than a handful of lawyers; request volume is in the hundreds per quarter; external legal spend is material enough that Finance asks about it; the company signs standard contracts at volume (sales-led growth); litigation or investigations recur; the GC cannot answer “how long do contracts take” or “what will we spend this year”.

Do not build a team when: the company has one or two lawyers and modest volume. Assign legal operations as a part-time responsibility (often a paralegal or the GC’s chief of staff), set up a front door, three templates and a spend tracker, and stop. Do not lead with a platform when you have no intake data, no templates and no owner for contract metadata.

Hidden responsibilities. Someone must own templates forever, integrate legal systems with HR, CRM and procurement, keep hold evidence, and maintain the panel. If nobody will own them, the tools decay.

flowchart TB
  Q1{"More than about 3 lawyers or hundreds of requests a quarter?"} -->|no| S1["Part-time owner: front door, 3 templates, spend tracker"]
  Q1 -->|yes| Q2{"Do you know volume, type and cycle time of requests?"}
  Q2 -->|no| S2["Start with intake and triage for 60 days"]
  Q2 -->|yes| Q3{"Biggest pain: contracts, spend or disputes?"}
  Q3 -->|contracts| S3["Templates, playbooks, signature matrix, then CLM"]
  Q3 -->|spend| S4["Panel, guidelines, LEDES e-billing, phase budgets"]
  Q3 -->|disputes| S5["Hold process, HR leaver link, provider panel"]
  S3 --> REV["Review scorecard quarterly; next priority"]
  S4 --> REV
  S5 --> REV
  classDef decision fill:#fdf3e3,stroke:#c9800f,color:#122029
  classDef core fill:#e8f3f2,stroke:#16756f,color:#122029
  classDef neutral fill:#f1f4f6,stroke:#5b7a87,color:#122029
  class Q1,Q2,Q3 decision
  class S2,S3,S4,S5,REV core
  class S1 neutral

Weighted comparison for the first major investment (scores 1–5; weights are assumptions to replace with yours):

Arithmetic for the first column: 0.30×4 + 0.25×5 + 0.20×2 + 0.15×5 + 0.10×5 = 1.20 + 1.25 + 0.40 + 0.75 + 0.50 = 4.10. A company with active litigation would weight risk reduction higher, which can put the hold tool first.

flowchart TB
  L1["1 Ad hoc"] --> L2["2 Captured"]
  L2 --> L3["3 Standardised"]
  L3 --> L4["4 Managed"]
  L4 --> L5["5 Optimising"]
  L1 -.-> T1["Trap: buying a platform first"]
  L2 -.-> T2["Trap: data nobody reviews"]
  L3 -.-> T3["Trap: CLM used by Legal only"]
  L4 -.-> T4["Trap: savings counted, outcomes ignored"]
  classDef core fill:#e8f3f2,stroke:#16756f,color:#122029
  classDef risk fill:#fbeceb,stroke:#b4332b,color:#122029
  class L1,L2,L3,L4,L5 core
  class T1,T2,T3,T4 risk

Quick wins. A self-service mutual NDA; a one-page “how to get legal help” guide; a renewal list for the top 50 contracts by value. Dependencies. IT for identity and retention settings; HR for leaver data; Finance for matter-level accruals.

Quick start (first two weeks)

• One front door published, with a sensitive lane
• Eight to twelve request types and a routing owner for each
• List of where signed contracts live today
• List of active matters, firms, budgets and active legal holds
• Baseline: requests per week, by type

Contract desk readiness

• Current template per top contract type, with an owner and version
• Playbook with fall-backs and approvers per clause
• Signature matrix enforced in the e-signature tool
• Minimum metadata fields mandatory at storage
• Renewal alerts to business owners tested

Outside counsel and spend

• Guidelines attached to every engagement letter
• Phase budget within 30 days of engagement
• LEDES invoices with UTBMS codes required
• Rules for rates, codes, arithmetic and expenses configured; held lines tracked separately from reductions
• Monthly accrual process agreed with Finance

Legal hold audit (per active hold)

• Trigger decision and date recorded by a lawyer
• Scope covers current and recently departed custodians, systems and third parties
• Notices sent with acknowledgement mechanism; non-responders escalated
• IT confirmed auto-delete suspension per system
• Reminder schedule set; release procedure defined

Quarterly continuous improvement

• Scorecard reviewed with GC; one improvement chosen
• Most-used fall-backs reviewed for template changes
• Firm performance notes updated
• AI tool use reviewed against policy and outcomes

Template status: plain text; adapt and have the GC approve.

LEGAL OPERATIONS CHARTER                                   Version: ____
Mission     Legal service the business can predict and the company can defend.
Scope       Intake and triage; contract lifecycle; outside counsel and spend;
            legal holds and e-discovery operations; legal tech; metrics.
Not in scope Legal advice (lawyers); privacy programme (PrivacyOps);
            sourcing and payment (Procurement).
Principles  Demand is data. Right work, right resource. Standardise before
            automating. Lawyers own judgement; Ops owns the system.
Owners      GC (accountable). Head of LegalOps (responsible).
Measures    First response, cycle time by type, no-lawyer-touch rate,
            spend vs budget, hold acknowledgement, satisfaction.
Cadence     Weekly queue, monthly spend, quarterly scorecard, annual panel.
Escalation  Urgent requests: ______  Over authority: ______  Holds: ______
Review      Annually, or when the department's scope changes.

Template status: plain text skeleton; counsel writes the matter-specific content.

PRIVILEGED AND CONFIDENTIAL - LEGAL HOLD NOTICE              Hold ID: ______
To:        <custodian>                     Issued: <date>   By: <lawyer>
What:      Keep all documents and data about <subject>, from <date> to now,
           in any form: email, chat, files, phones, paper, notebooks.
Where:     Includes <systems>. Do not delete, edit, move or wipe devices.
           Auto-delete on <systems> has been suspended by IT; tell us if you
           see messages disappearing.
How long:  Until Legal tells you in writing that the hold is released.
Questions: <contact name, channel>.
Confirm:   Acknowledge within 5 business days: <link or reply instruction>.
Reminders: You will receive a reminder every <n> days.

Template status: CSV header with one synthetic row; one row per matter phase.

matter_id,matter_type,lawyer,firm,phase,budget,actual_to_date,afa_type,hold_id
LIT-2026-014,commercial dispute,A. Lawyer,Firm A,L300 Discovery,250000,0,capped,H-2026-07

In-house LegalOps versus law-firm operations. Both run legal work as a business, but the economics differ: the in-house team buys legal services and is a cost centre judged on service and risk; a law firm sells hours or outcomes and is judged on margin, utilisation and pricing. CLOC opened its membership to the wider legal ecosystem in 2021,^[5] and its playbook committee includes law-firm members,^[4] so the vocabulary is shared even where incentives are opposite.

Delivery models for legal work.

Do legal operations professionals need to be lawyers? No. CLOC describes people coming from finance, marketing, data analytics and learning and development.^[2] They do need enough legal literacy to know when a question is legal, and a clear rule that lawyers make legal judgements.

Is there a certification? Not yet: CLOC’s LOCP exam first runs in May 2027 (see the naming story).^[7] Until then there are courses and certificates, which CLOC itself distinguishes from a certification.

Should we buy a CLM first? Usually not. Collect intake data and fix templates, playbooks and signature authority first; then the CLM requirements are yours, not the vendor’s demo script (see the judgement call).

What is the difference between LEDES and UTBMS? LEDES is the file format for invoices (and budgets), maintained by the LEDES Oversight Committee; UTBMS is the coding system for what the work was (task, activity, expense).^[24][12] You need both: the format makes invoices machine-readable, and the codes make them comparable.

Who owns legal holds: Legal, IT or records management? A lawyer decides the trigger and scope and is accountable; LegalOps runs notices, tracking and evidence; IT preserves data at source; records management makes sure retention schedules yield to holds. Sedona’s guidelines describe the process, not an org chart.^[13]

Can we let an AI tool review contracts without a lawyer? For standard paper within a playbook, an AI tool can assist the same people who already handle it without a lawyer; outputs still need a named human reviewer. Anything going to a court needs a lawyer’s verification.^[26] Check the tool’s confidentiality terms and the approval route described in Automation and AI.

• Established now: structured e-billing (LEDES, UTBMS), template and playbook-driven contracting, legal hold platforms, the CLOC and ACC reference models.
• Actively changing (as of October 2026): professionalisation (CLOC’s LOCP certification);^[7] EDRM 2.0 (September 2026), which elevates analysis across the lifecycle to reflect analytics, machine learning and generative AI;^[11] and generative AI in legal work generally, where courts and bar bodies already expect verification (Automation and AI).
• Plausible but unproven at scale: AI agents that negotiate within playbooks end to end; automated obligation extraction that is reliable enough to drive payments without human checks. Treat vendor claims here as hypotheses to test on your own contracts.
• Data ethics: law-firm diversity metrics, which the ACC model’s intermediate and advanced stages include,^[1] raise questions about what data firms may share and how; decide with counsel and in line with local law.

Situation (illustrative). A 1,500-person software company; legal team of six; sales complains that contracts take too long; the CFO has approved budget for “a contract system” this financial year and wants it live by the next quarter-end.

Option A: buy and implement a CLM now. Attractive: the budget exists, the CFO wants visible action, vendors promise templates and AI review out of the box, and a repository would answer “where is the contract?”.

Option B: spend 90 days on intake, templates, playbooks and signature authority, then buy. Attractive: the team learns what actually slows contracts down, and the CLM is configured around proven templates.

Assumptions to test. (1) Is Legal actually the bottleneck? Without time-in-state data nobody knows; counterparties and internal approvers may hold contracts longer than lawyers do. (2) Do templates exist and are they current? (3) Will sales use a new tool, or does contracting have to start from the CRM?

Decision process. Run four weeks of intake with status timestamps on the top three contract types (cheap, reversible). If Legal holds most of the cycle and templates exist, Option A’s case is strong: buy, with templates loaded on day one. If time is mostly with counterparties or approvers, the fix is playbook fall-backs and approval rules; a CLM bought first would automate the wrong step. A middle path keeps the CFO’s budget: sign the CLM contract with a phased start, configured after the process work.

Why the attractive choice can be wrong. Option A answers the CFO’s request but not the business’s problem when the delay is elsewhere, and a tool rolled out to Legal only (the common failure) leaves sales emailing contracts as before. Uncertainty. If the company is about to double its sales team, waiting carries a real cost; that is the case for the phased middle path.

After this page you should be able to:

1. Explain what legal operations covers and where its boundaries with procurement, compliance and privacy lie.
2. Design an intake form and routing matrix with a sensitive lane.
3. Build a contract playbook and choose metrics for a contract desk.
4. Set up e-billing rules using LEDES and UTBMS and interpret the results honestly.
5. Run a defensible legal hold process and handle a departed custodian.
6. Decide which investment comes first and defend the choice with data.

Self-check questions.

LegalOps is an established function with a professional community, two reference models and long-standing data standards, even if the one-word label is informal. Its value is not in any single tool: it comes from counting demand, routing work to the right resource, standardising what is routine so lawyers can concentrate on judgement, managing outside counsel with structured data, and building preservation and privilege into everyday workflows. Start with a front door and a baseline, fix the flow that hurts most, and let your own data choose the next investment. Where law is involved, name the jurisdiction, date the statement and let counsel decide.

Further reading

• CLOC State of the Industry Report — CLOC; member-only benchmarking based on the Harbor Law Department Survey (no figures from it are used on this page).
• Related Atlas pages: ProcurementOps, ComplianceOps, PrivacyOps, KnowledgeOps, ResponseOps, PeopleOps.

Changelog

• 2026-10-23 — First version: researched, drafted, labs executed, validated (managing author).
• 2026-10-23 — Round-1 revision after independent review: Capital One facts and work-product framing, PD 57AD 4.2 condition, Sedona attribution, reduction-rate denominator (Lab 2 re-run), in-house client and OCG AI clause corrected or added; repetition trimmed (author).
• 2026-10-23, post-score polish: footnoted CLOC’s Solutions Directory; Sedona “binding?” cell softened to non-binding consensus guidance; LOCP eligibility made precise with a re-check trigger; LOCP, cost-cutting and AI restatements trimmed to cross-references; ABA Opinion 512 still via the NCBE summary (ABA PDF and mirrors not fetchable) (author).