Salesforce · Litify Automation

A matter plan that nobody follows is just a to-do list with extra steps

Litify generates stages and tasks when a matter opens. Whether anyone acts on them depends on things the package cannot decide for you: whether the dates are real, whether the work lands on a role rather than a person who left, and whether the automation underneath fires in an order somebody actually designed. We build automation your team stops working around.

Automation Architecture
WHAT TRIGGERS WORK Matter Opens Case Type selects the plan Stage Changes Next task set generated Inbound Documents Dates Passing Field Updates THE AUTOMATION LAYER Matter Plans Stages · Task templates Role assignment Date Logic Statutory · Court Firm policy rules Escalation Warnings · Reassign Supervisor alerts ONE EXECUTION ORDER, DOCUMENTED 2πr WHAT THE TEAM SEES A Task List That is right, without anyone curating it Deadlines With Warning Surfaced early enough to actually act on No Chasing Work moves without someone asking twice
1
Execution order, designed and documented
4
Automation types rationalised into a single model
12+
Years of Salesforce delivery
40+
Consultants, architects & developers

Trusted by 500+ organizations — including law firms and legal technology companies building their case, billing and reporting operations on Salesforce with Twopir Consulting.

Social Justice Collaborative
Bernstein Liebhard LLP
LegalZoom
Sterling Law Offices, S.C.

Automation Capability

  • Salesforce Partner
  • Matter Plans
  • Salesforce Flow
  • Deadline Logic
  • Role Assignment
  • Validation Rules
  • Escalation Design
  • Automation Audit
Where Automation Goes Wrong

Six ways automation quietly stops working

Every one of these starts as a reasonable decision by a competent person. They only become problems in aggregate, which is why nobody notices until the whole thing needs untangling.

Tasks arrive with dates nobody believes

A task due "7 days after matter open" on a case where nothing happens for a month teaches people to ignore due dates. Once they ignore one, they ignore all of them, and the plan stops being a schedule.

Work is assigned to people, not roles

Someone leaves, goes on leave, or moves practice, and a hundred open matters still route work to them. Assignment by matter role survives staffing changes; assignment by named user does not.

Nobody knows what fires first

Four Flows, six validation rules and a trigger, added over three years by different people. Each is sensible alone. Nobody has ever mapped what happens on a single record save, which is why the edge cases are unexplainable.

Validation rules that block real work

A required field that made sense for one case type blocks a different one at 6pm on a filing day. People find the workaround — usually a junk value — and the data quality the rule existed to protect is worse than before.

Deadline rules live in one paralegal's head

The real rule for each jurisdiction is known, accurate, and entirely undocumented. It is not in the system, it does not survive that person's holiday, and it leaves the firm when they do.

Automation that runs on every save

Logic that should fire on a stage change fires on every field update instead. It is slow, it double-sends notifications, and under bulk operations it hits limits that only show up when someone updates 200 matters at once.

What We Build

Automation with one designed execution order

Litify workflow automation is the layer that makes a matter move without anyone chasing it. Matter plans generate stages and tasks when a matter opens, based on its Case Type. Around that, Salesforce Flow, validation rules and assignment logic handle everything the plan cannot express on its own: dates that depend on jurisdiction, escalation when something sits too long, and the conditions under which the next stage should open.

The technical fact that governs all of it is that Litify is a Salesforce application, so its automation runs inside Salesforce's order of execution alongside everything else in your org. Flows, validation rules, Apex triggers and the package's own logic all fire in a defined sequence. Most law firm orgs have never had that sequence mapped, which is exactly why automation behaves in ways nobody can explain.

Our build rule is configuration first, code only where configuration genuinely cannot reach. A matter plan with good task templates and a well-built Flow covers far more than most firms expect, and every piece of Apex you avoid is one less thing to maintain and test through the vendor's next release.

Matter Plans

Stages and task templates per case type, generated and assigned automatically when a matter opens.

Date Logic

Statutory, court and firm-policy deadlines calculated from the right basis, with warnings before they bite.

Role Assignment

Work routed to a matter role rather than a named user, so staffing changes do not orphan tasks.

Salesforce Flow

Record-triggered and screen Flows for everything the plan cannot express, built in a designed order.

Validation

Rules that protect data quality at the point of entry without blocking legitimate work.

Escalation

What happens when something sits too long — who gets told, when, and what changes.

Bulk Safety

Automation that survives a 200-record update, because eventually somebody will do one.

Observability

Error handling and logging, so a silent failure is something you find out about.

Three Situations

Build it, rebuild it, or untangle what is there

Automation work divides cleanly by what already exists. Be honest about which column you are in — building on top of an unmapped automation layer is how orgs end up unexplainable.

Situation 01 · Build

New matter plans for a practice area

Greenfield automation, either as part of an implementation or when adding a practice. The process decisions exist; the job is expressing them so they run reliably.

  • Stage model translated into a matter plan
  • Task templates with defensible date logic
  • Assignment by matter role throughout
  • Deadline rules encoded and tested
  • Escalation thresholds and notification design
  • Bulk-safe from the start, not retrofitted

Assumes The process decisions are already made. If two partners still describe the stage model differently, that is an operating-model conversation first.

Situation 02 · Rebuild

The plans exist but nobody follows them

The most common engagement. Plans were built from a template or in a hurry, the dates were never realistic, and the team has quietly gone back to a spreadsheet.

  • What the current plans actually generate
  • Where the dates diverge from real practice
  • Which tasks get closed without being done
  • Redesign with the people who use them
  • Phased rollout so live matters are safe
  • Adoption measured after, not assumed

Assumes Live matters are running on the current plans, so the change has to be staged. We do not rewrite plans under active cases without a migration path.

Situation 03 · Untangle

Automation nobody can explain any more

Years of accumulated Flows, validation rules and triggers interacting in ways nobody has mapped. The symptom is usually "it does things we did not ask for".

  • Full inventory with ownership and last-modified
  • Order of execution mapped end to end
  • Conflicts, loops and redundancy identified
  • Dead automation retired safely
  • Consolidation into a designed model
  • Documentation your admin can maintain

Assumes Nothing. This is archaeology before engineering — and if the tangle is bad enough, an audit is the cheaper way to scope it first.

Which automation tool handles which job in a Litify org, and why the choice matters
The jobWhat we build it withWhy not something else
Generate the task list when a matter opensLitify matter plan stages and task templates. Native to the package, visible to your admin, and upgraded by the vendor.Matter Plan
A due date that depends on jurisdiction or case factsRecord-triggered Flow, reading the rule from custom metadata rather than hard-coding it in a formula.Flow
Reassign and alert when a task sits too longScheduled-path Flow with the threshold in metadata, so ops can tune it later without a developer.Flow
Stop bad data at the point of entryValidation rules, scoped tightly by record type and case type so they never block a legitimate path.Validation
Logic that must run across thousands of recordsApex, batched and bulk-safe, with tests. Flow hits limits here and fails in ways users see.Apex
A multi-step screen that is not a record pageA Screen Flow, or a Lightning Web Component when the interaction is richer than Flow can express.Flow / LWC
What We Deliver

Six pieces of automation, built to be maintained by you

Everything here is handed over with documentation your own admin can act on. Automation only one consultant understands is a liability whoever built it.

Matter Plan Design & Build

The core of Litify automation. Stages the team recognises, task templates with dates they will defend, and assignment that survives someone leaving.

  • Stage models per case type
  • Task templates with realistic date logic
  • Assignment by matter role throughout
  • Conditional tasks by case facts
  • Plan versioning as practice areas change
  • Migration path for matters on old plans

Deadline & Date Automation

The highest-stakes automation in a law firm. Rules held in metadata rather than hard-coded, so they can be updated without a deployment.

  • Statutory and court deadline calculation
  • Jurisdiction rules in custom metadata
  • Business-day and holiday handling
  • Warning intervals before each deadline
  • Override authority and audit trail
  • A named owner for the rule set

Flow Architecture

One record-triggered Flow per object per timing, sub-flows for reusable logic, and a documented execution order. The discipline is what keeps it explainable in three years.

  • One Flow per object per timing context
  • Sub-flows for genuinely reusable logic
  • Entry criteria that stop needless execution
  • Fault paths and error notification
  • Naming and documentation conventions
  • Bulk-safe by construction

Escalation & Notification

What happens when something sits too long. Tuned deliberately, because an alert everyone ignores is worse than no alert at all.

  • Thresholds per task and case type
  • Supervisor and partner escalation paths
  • Reassignment on absence or overload
  • Digest rather than per-event where sensible
  • Quiet hours and weekend handling
  • Thresholds in metadata for ops to tune

Validation & Data Quality

Rules scoped tightly enough that they never block legitimate work, because the workaround for a bad validation rule is always junk data.

  • Rules scoped by record type and case type
  • Stage-gate criteria for progression
  • Required-field logic that matches real practice
  • Duplicate prevention on intake
  • Bypass paths for genuine exceptions
  • Error messages that say what to do

Automation Audit & Rationalisation

The untangling engagement. An inventory, an execution-order map, and a consolidation plan that retires what is dead without breaking what is load-bearing.

  • Full inventory with ownership and dates
  • Order of execution mapped end to end
  • Conflicts, loops and redundancy identified
  • Dead automation retired safely
  • Consolidation into a designed model
  • Documentation handed to your admin
Design Rules We Apply

The conventions that keep automation explainable

These are the rules we build to, every time. They are unglamorous and they are the whole reason an org is still maintainable three years after the consultants left.

One Flow Per Object Per Timing

A single before-save and a single after-save Flow per object, with sub-flows for reusable logic. Multiple record-triggered Flows on one object means the execution order is decided by the platform, not by you.

Prevents The "four Flows fighting each other" problem that makes automation unexplainable and edge cases unreproducible.

Assignment By Role, Never By Name

Every task lands on a matter role. When someone leaves or goes on leave, you change the role assignment on the matter and a hundred open tasks route correctly.

Prevents Orphaned work after any staffing change — the single most common cause of missed tasks in a live org.

Rules In Metadata, Not In Formulas

Deadline intervals, escalation thresholds and jurisdiction rules live in custom metadata records. Operations can change a threshold without a developer, a deployment or a release window.

Prevents A change request queue for values that should be editable by the people who own the process.

Entry Criteria On Everything

Automation that should fire on a stage change fires only on a stage change. Without tight entry criteria it runs on every save — slow, noisy, and dangerous under bulk operations.

Prevents Duplicate notifications, needless processing and limit failures when somebody mass-updates 200 matters.

Fault Paths On Every Flow

Every Flow has an error path that notifies a named person. The alternative is a Flow that fails silently and a record that quietly never progressed.

Prevents Silent failures — where the first sign of a problem is a partner noticing a matter stalled three weeks ago.

Bulk-Safe By Construction

Automation is designed and tested against a 200-record operation from the outset, not patched when it first fails. Data loads, mass reassignment and integration writes all arrive in bulk.

Prevents Governor limit failures that only appear during a migration or a mass update, when they are most costly.
How We Deliver

Five phases, and nothing goes live untested

Automation touches live matters and live deadlines, so every phase here is built around not breaking something that is currently working.

Phase 01

Inventory

What exists today: matter plans, Flows, validation rules, Apex and assignment logic, with ownership and last-modified dates. If Litify is already live we confirm the objects and package version in your org rather than assuming them.

Phase 02

Map Execution Order

Every path a record can take on create and update, traced across the whole automation layer in firing order. Most orgs have never had this done, and it is where the unexplainable behaviour resolves.

Phase 03

Design

The target model: which job each tool does, what moves into metadata, what gets retired. Reviewed with your admin, because they maintain it after we leave.

Phase 04

Build & Test

Built in a sandbox and tested against real matters from your own history, including a bulk test. Nothing reaches production on the strength of a single-record happy path.

Phase 05

Roll Out & Hand Over

Phased so live matters are never at risk, with a migration path for matters running on old plans. Documentation goes to your admin, not into a folder nobody opens.

Why we do not just start building Adding automation to an org whose execution order has never been mapped is how the tangle got there in the first place. The inventory and mapping phases usually take under a week and they routinely change the design — we have found Flows nobody knew were running, validation rules that had been bypassed for a year, and two automations quietly doing the same job in opposite directions. Building on top of that without looking first is not faster.

Who This Is For

Four teams that feel this first

Automation failures show up in different places depending on who you are. All four of these describe the same underlying problem.

Operations Managers

Who own the matter plans, field the "why did this task appear" questions, and cannot tune a threshold without raising a ticket.

Senior Paralegals

Who hold the real deadline rules and want them in the system rather than in their head — and want the system to get them right.

Litify Admins

Inside the firm, holding a backlog of automation requests on top of a layer they inherited and cannot fully map.

Practice Group Heads

Whose team is measured on cycle time and who can see that the delay lives in the handoffs, not in the legal work.

Client Outcomes

Legal platforms we have actually built

Two engagements from our legal practice. Both depended on automation that had to hold under real caseload — the numbers below are what that discipline produced.

★★★★★
Twopir provided Salesforce customisation and integration services to help us build a robust, compliant, and scalable legal operations platform — connecting case management, document processing, and financial systems into one unified workflow. The result was transformative for how we run case-to-cash operations.
Operations Lead Fast-growing personal injury law firm Personal Injury
Case Study

Personal Injury Firm — Multi-State

Streamlining case-to-cash operations with Salesforce, AWS and QuickBooks.

40%+ Faster case-to-settlement processing
45% Reduction in reconciliation effort
35% Improvement in data accuracy
Read Full Case Study
★★★★★
Twopir's specialized Salesforce customization enabled efficient integration of third-party systems and streamlined administration and billing, leading to seamless financial operations and enhanced productivity. Automated mass billing and matter management minimized errors across our entire legal workflow.
Practice Manager Mid-size US family law firm · 150 employees Family Law
Case Study

Family Law Firm — 150 Employees, US

A 50% efficiency gain from Accounting Seed and Salesforce integration.

50% Increase in operational efficiency
45% Productivity gains from automation
35% Faster lead qualification & conversion
Read Integration Story
Why Twopir

Automation you can maintain without us

The measure of good automation work is whether your own admin can change a threshold on a Tuesday without calling anyone. We build to that standard deliberately.

We map the execution order before we add to it

Every path a record can take on create and update, traced across Flows, validation and Apex in firing order. It usually takes under a week, it routinely changes the design, and almost no org has ever had it done.

Configuration first, code only where it cannot reach

A good matter plan and a well-built Flow cover far more than most firms expect. Every piece of Apex avoided is one less thing to test through the vendor's next release — and Litify ships releases.

Tunable values live in metadata

Deadline intervals, escalation thresholds and jurisdiction rules are metadata records, not hard-coded formulas. Your operations lead changes them; nobody needs a developer or a deployment window.

We extend around the package, never into it

Custom objects, Apex, Flow and Lightning Web Components built so the vendor's next release upgrades cleanly. A firm that cannot take a Litify upgrade has bought a fork, not a platform.

We work with growing and mid-market companies

We help growing and mid-market companies solve complex CRM, integration and business system challenges, and we serve enterprise organizations with the same architecture discipline. Firms at that stage need a system that survives the next three years of growth — not one built for the org chart they had last year.

Common Questions

Answers before the first call

Almost always one of three causes. The due dates are not realistic for how those cases actually run, so people learn to ignore them and then ignore all of them. The tasks are assigned to named users rather than matter roles, so staffing changes orphan them. Or the plan was copied from a template and describes a process the team does not follow. The fix starts by looking at which tasks get closed without being done — that pattern tells you precisely which parts of the plan are fiction.

A matter plan is Litify's own structure: it generates a set of stages and tasks when a matter opens, based on the Case Type, and assigns them by role. It is configuration inside the package, visible to your admin, and the vendor upgrades it. Salesforce Flow handles everything the plan cannot express on its own — a due date that depends on jurisdiction, escalation when a task sits too long, conditional logic based on case facts. Good Litify automation uses the plan for the predictable skeleton and Flow for the judgement, rather than pushing everything into one of them.

Yes, and it is a common starting point. The cause is usually order of execution: several Flows, validation rules and possibly Apex triggers added over years by different people, each sensible alone, interacting in a sequence nobody has mapped. We inventory everything with ownership and last-modified dates, then trace every path a record can take on create and update in firing order. That exercise nearly always surfaces automation nobody knew was running, and it is what makes the edge cases explainable again.

That is an explicit design goal. Tunable values — deadline intervals, escalation thresholds, jurisdiction rules — live in custom metadata records rather than hard-coded in formulas, so your operations lead can change a threshold without a developer or a deployment. We build to a documented convention: one record-triggered Flow per object per timing, sub-flows for reusable logic, fault paths on everything, clear naming. Documentation is handed to your admin as part of the work, not offered as an extra.

Not if it is staged properly, which is why we never rewrite plans under active cases without a migration path. We work out which matters are on which plan version, decide with you whether in-flight matters move or finish on the old model, and roll out by practice area or case type rather than all at once. Live deadlines are the thing we are most careful about — losing one is a different category of problem from losing a report.

The rules go into custom metadata, one record per jurisdiction and case type, with the calculation basis, business-day handling and warning intervals as fields. Flow reads the rule rather than containing it. That matters for two reasons: the rules can be updated by the firm when a court changes its practice, without a code deployment; and the rule set has a named owner and an audit trail, rather than living in one senior paralegal's head where it does not survive their holiday.

No, and the distinction matters. This is deterministic automation — given these conditions, this task is created, this date is calculated, this person is notified. It does the same thing every time and you can audit why. Litify's AI agents and Agentforce are probabilistic: they read your records and produce judgements. Both are useful, but agents read the records deterministic automation creates, so getting this layer right first is what makes the AI layer worth turning on at all.

Next Step

If your team works around the matter plan, the plan is the problem

A first conversation covers which tasks actually get done, where work stops between people, and whether you need new automation or an untangling of what is already there.

Inventory · execution order · configure first · bulk-safe · documented handover