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.
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.
Trusted by 500+ organizations — including law firms and legal technology companies building their case, billing and reporting operations on Salesforce with Twopir Consulting.








Automation Capability
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.
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.
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.
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.
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.
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.
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.
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.
Stages and task templates per case type, generated and assigned automatically when a matter opens.
Statutory, court and firm-policy deadlines calculated from the right basis, with warnings before they bite.
Work routed to a matter role rather than a named user, so staffing changes do not orphan tasks.
Record-triggered and screen Flows for everything the plan cannot express, built in a designed order.
Rules that protect data quality at the point of entry without blocking legitimate work.
What happens when something sits too long — who gets told, when, and what changes.
Automation that survives a 200-record update, because eventually somebody will do one.
Error handling and logging, so a silent failure is something you find out about.
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.
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.
Assumes The process decisions are already made. If two partners still describe the stage model differently, that is an operating-model conversation first.
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.
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.
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".
Assumes Nothing. This is archaeology before engineering — and if the tangle is bad enough, an audit is the cheaper way to scope it first.
Scroll the table sideways →
| The job | What we build it with | Why not something else |
|---|---|---|
| Generate the task list when a matter opens | Litify 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 facts | Record-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 long | Scheduled-path Flow with the threshold in metadata, so ops can tune it later without a developer. | Flow |
| Stop bad data at the point of entry | Validation rules, scoped tightly by record type and case type so they never block a legitimate path. | Validation |
| Logic that must run across thousands of records | Apex, 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 page | A Screen Flow, or a Lightning Web Component when the interaction is richer than Flow can express. | Flow / LWC |
Everything here is handed over with documentation your own admin can act on. Automation only one consultant understands is a liability whoever built it.
The core of Litify automation. Stages the team recognises, task templates with dates they will defend, and assignment that survives someone leaving.
The highest-stakes automation in a law firm. Rules held in metadata rather than hard-coded, so they can be updated without a deployment.
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.
What happens when something sits too long. Tuned deliberately, because an alert everyone ignores is worse than no alert at all.
Rules scoped tightly enough that they never block legitimate work, because the workaround for a bad validation rule is always junk data.
The untangling engagement. An inventory, an execution-order map, and a consolidation plan that retires what is dead without breaking what is load-bearing.
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.
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.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.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.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.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.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.Automation touches live matters and live deadlines, so every phase here is built around not breaking something that is currently working.
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.
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.
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.
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.
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.
Automation failures show up in different places depending on who you are. All four of these describe the same underlying problem.
Who own the matter plans, field the "why did this task appear" questions, and cannot tune a threshold without raising a ticket.
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.
Inside the firm, holding a backlog of automation requests on top of a layer they inherited and cannot fully map.
Whose team is measured on cycle time and who can see that the delay lives in the handoffs, not in the legal work.
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.
Streamlining case-to-cash operations with Salesforce, AWS and QuickBooks.
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.
A 50% efficiency gain from Accounting Seed and Salesforce integration.
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.
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.
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.
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.
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 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.
This page covers one service. Each one below goes into the detail a specific team needs — pick the one closest to the question you arrived with.
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.
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