Most firms buy Litify for matters and billing, then discover the hard part is everything around it — case types, matter plans, referral flows, eBilling rules, document storage and the reporting partners actually trust. Twopir Consulting configures Litify and builds on the Salesforce platform underneath it. Intake, matters, billing and reporting on one architecture.
Trusted by 500+ organizations — including law firms and legal technology companies building their case, billing and reporting operations on Salesforce with Twopir Consulting.
Litify Delivery Capability
Litify ships a strong data model — Intake, Matter, Case Type, Matter Plan, Role, Time Entry, Invoice. What it cannot ship is the decision about how your firm uses them. That decision is the project, and it is where most stalled implementations went wrong.
Case Type drives the intake questionnaire, the matter plan and every integration that creates an intake by ID. Firms that set it up as a flat picklist end up with one generic plan for twelve different kinds of case — and no reporting dimension worth having.
Stages and tasks generated at matter open are only useful if they match how the team actually works, carry real due-date logic, and land on the right role. Plans built from a vendor template get closed in bulk within a month, and the pipeline data goes with them.
Leads arrive from forms, phones, campaigns and referrals, then wait on a person to triage them. Without routing rules, SLA clocks and a qualification model on the Intake record, the firm is buying attention it cannot convert.
Carrier guidelines, LEDES task and activity codes, rate caps and block-billing rules only reduce write-downs if they are enforced at time of entry. Enforced after the fact, they become a monthly argument with the client instead.
Files land in email, shared drives and the document layer at the same time. Without a folder convention per case type, naming rules and a filing path for inbound mail, the matter record stops being the place anyone looks first.
Every field in Litify is reportable, which is not the same as being reported well. Inconsistent stage definitions, free-text where a picklist belonged and no agreed date fields mean two dashboards answer the same question differently — so leadership goes back to the spreadsheet.
Litify is a legal practice and legal operations platform built as a managed package on Salesforce. It gives law firms and in-house legal teams a shared data model for the whole case lifecycle: a prospective case arrives as an Intake on a client account, and once signed it becomes a Matter whose Case Type selects the Matter Plan of stages and tasks, and whose parties are linked as Roles. Work on that matter produces requests, negotiations, resolutions and expenses on the plaintiff side, and time entries and invoices — including LEDES eBilling — on the billing side.
Because it is a Salesforce application rather than a standalone system, everything the platform provides sits on Salesforce's own foundations: the security model, sharing rules, reports and dashboards, Flow, Apex, Lightning Web Components, the API surface and the AppExchange. That is the single most important fact for anyone planning an implementation — the ceiling on what Litify can do for your firm is a Salesforce ceiling, not a Litify one. It is also why a Litify project needs Salesforce architects, not only legal-software administrators. Product details are on Litify's own platform documentation.
Twopir Consulting is a Salesforce consultancy that implements, configures and extends Litify. We are not Litify, and we do not resell it — you license the platform from the vendor. What we build is everything between the package and your firm: the case-type architecture, the matter plans, the intake and billing logic, the integrations, the reporting layer and the custom development the package does not cover.
The lead record, screened through a dynamic questionnaire that jumps to the next relevant question by case type, then converted to a matter on sign-up.
The case: the hub every event, document, call, email, time entry, request, negotiation, resolution and expense attaches to.
Templated stages and task lists per case type, created and assigned by role automatically when a matter opens.
Defendants, insurers, opposing counsel, providers and the matter team — each linked to the matter in a named capacity.
Folders and files on the matter, with document generation, PDF editing and Outlook filing — or a connected DMS such as iManage or NetDocuments.
Time entries checked at capture for missing codes and rate mismatches, pre-bills, mass billing runs and LEDES eBills to carriers and clients.
Incoming and outgoing referral records moving cases between firms through the Litify Referral Network, Referrals Pro or Lexamica.
Named agents for intake qualification, conflict checks, matter summaries, damages and invoice review — plus Litify ACE and Salesforce Agentforce.
These are three different engagements bought by three different people, and mixing them up is the most common reason a Litify budget runs out early. Find the column that describes where you are.
A first deployment: the package is installed, and the firm needs a working operating model on top of it — designed, built, migrated to and adopted.
Boundary Ends when the firm is running live matters in Litify with reporting the partners accept. Custom code only where configuration genuinely cannot reach.
An existing org that under-performs. Usually the data model was set up in a hurry, the plans do not match the practice, or a second practice area was bolted on.
Boundary Works inside the existing org — no rebuild from a blank org unless the audit shows one is genuinely cheaper than the repair.
Custom development on the Salesforce platform around the package: integrations, custom objects and UI, agents, and logic specific to how your firm runs.
Boundary Built to survive Litify's own upgrades: we extend around the managed package and never modify what the vendor ships.
| What you want | How it is actually delivered | Which side |
|---|---|---|
| A new practice area | New case types, questionnaire branches and a matter plan. Point-and-click work in the package, plus the reporting dimensions to go with it. | Configuration |
| Deadline rules a paralegal can trust | Task templates with date logic on the matter plan, backed by Salesforce Flow where the rule depends on jurisdiction or case facts. | Configuration |
| Carrier billing guidelines enforced | Billing rules, LEDES task and activity codes, validation at time of entry. Configuration until a carrier's rule needs logic no rule engine expresses. | Configuration |
| A two-way sync with your accounting system | A partner connector where one exists for QuickBooks, Accounting Seed or Sage Intacct — otherwise middleware or a custom integration with real error handling and replay. | Build On |
| A screen that is not a record page | A Lightning Web Component: an intake console, a settlement calculator, a referral-partner view. Apex behind it when it has to query or write at volume. | Build On |
| An AI agent that does firm-specific work | Litify's own named agents where one already fits. Agentforce with custom topics and actions over Litify data where it does not. | Build On |
Six workstreams. Most engagements use three or four of them; almost none need all six at once, and we will tell you which ones your firm can skip.
Turn inbound volume into signed matters with a qualification model, not a queue. The intake record becomes the place a case is worked, not a form someone fills in afterwards.
The architectural core of a Litify build. Case Type drives the questionnaire, the plan and the integrations — so it gets designed first, deliberately, with reporting in mind.
Realization is won at the moment an entry is written, not at the month-end review. We put the client's own rules in front of the timekeeper while the work is still fresh.
Litify is one system in a stack. We design the boundaries — what is master where, what syncs, what direction it moves, and what happens when a call fails at 2am.
Reporting fails on definitions, not on charts. We agree what a stage means and which date counts before anyone builds a dashboard on top of it.
AI is worth configuring once the data underneath it is trustworthy — and worth postponing until it is. We are direct with clients about which of those two situations they are in.
Litify is a Salesforce application, so integration uses the Salesforce API surface, AppExchange connectors and standard middleware — not a proprietary gateway. The design question is never "can it connect". It is what is master where, and which way the data moves.
Matter expenses, time and invoices reach the ledger without re-keying, and payment status comes back so the matter shows what has actually been collected. Connectors exist for QuickBooks, Accounting Seed and Sage Intacct.
Moves Invoices, expenses as bills, settlement receipts, parties as customers or vendors, payment and refund status.Files can live in Litify's own document layer or in the firm's DMS. Where a firm has standardised on iManage or NetDocuments, the matter stays the index and the DMS stays the repository — one place to look, one place of record.
Moves Matter folder trees, generated documents, filed email and attachments, version and classification metadata.The sign-up packet is the moment an intake becomes a matter, so the executed agreement belongs on the record automatically. DocuSign and Adobe Sign both support a fully tracked round trip with status written back to the intake.
Moves Retainer and engagement packets out; executed documents, timestamps and signer audit trail back in.Service of process and court filings are ordered against a matter and its parties, and the status belongs back on the matter rather than in a vendor portal a paralegal has to remember to check.
Moves Service orders against a matter Role, proof of service, docket filings landing in the matter's document folder.Defense firms bill insurers in LEDES format against the carrier's guidelines. Getting this right is the difference between a clean submission and a write-down argument, so the rules belong upstream of the invoice, not in the review.
Moves LEDES invoices with task and activity codes, budget and rate data, rejection and adjustment codes returning for scorecards.Cases outside a firm's practice are worth more referred than declined. Outgoing and incoming referrals are separate record types, and sending one populates the receiving firm's record — so attribution survives the handoff.
Moves Case type, client details, incident data and reference IDs out; incoming referrals converting into local intakes.Every inbound source should create an intake with its campaign attached, so marketing spend can be judged on signed matters rather than form fills. Integrations that create intakes need real Case Type record IDs, not names — a mapping step most projects discover late.
Moves Web form submissions, call and chat records, campaign and source attribution, client status updates going back out.The one most firms forget is not an integration at all. Litify shares the org with Sales Cloud, Service Cloud, Experience Cloud and everything else on the platform — so sharing rules, page layouts, automation order and API limits are a single shared design, not two.
Shares The security and sharing model, Flow execution order, API and storage limits, reporting, sandboxes and the release process.A focused implementation — core matter management, intake automation, billing setup and baseline reporting — typically runs 6 to 10 weeks. We would rather tell you that before the contract than after week six.
We map how the firm actually runs a case today, and — if Litify is already installed — confirm the namespace and object model in your own org rather than assuming it.
Case type taxonomy, matter plan models, the sharing and security design, integration boundaries and the metric definitions reporting will later depend on. Signed off before a build starts.
Configuration first, code only where configuration cannot reach. Built in a sandbox, reviewed with the people who will use it, and tested against real matters before anyone depends on it.
Data migration with reconciliation you can check, role-based training, and a parallel run so live matters and deadlines are never at risk during cutover.
Adoption measured rather than assumed, then the next tranche: another practice area, an integration, AI where the data is finally ready for it.
What makes it longer. Litify AI configuration, external integrations and complex workflow logic each extend the timeline — as does a migration from a system whose data was never clean. Structured matter templates and automated intake are what move the firm from signed engagement to a fully open matter in hours rather than days; that gain arrives at go-live, not before it.
The same platform, configured around completely different economics. A plaintiff firm optimises for intake conversion and settlement velocity; a defense firm optimises for realization against carrier guidelines. Those are not the same system.
High-volume intake with marketing ROI attached, referral flows in both directions, medical records and bills tracked as deadlines, damages and demand packets, negotiations and settlement disbursement.
Conflict checks before a matter opens, standardised matter plans across a carrier panel, time capture screened against billing guidelines, pre-bills, mass billing and LEDES eBilling with carrier scorecards.
Matter plans per visa type — family, student, corporate, PERM — with document collection checklists, form auto-fill from captured client data, a client portal and online payments.
A legal service request portal for the business, triage and routing, outside counsel collaboration, AI-assisted invoice review against billing rules and budgets, and spend dashboards the CFO will accept.
Two engagements from our legal practice. Both are Salesforce-architected case-to-cash builds — the same architecture discipline a Litify implementation depends on, applied to firms with the same operating problems.
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.
Litify problems are usually Salesforce problems wearing a legal label — a data model decision, an automation order-of-execution issue, a sharing rule, an integration boundary. That is the skill set the work actually needs.
Litify's object and field reference sits behind a customer login, and public sources disagree on details as basic as the namespace prefix. We confirm the real objects, fields and package version in your org in week one — and we say so rather than quoting from a blog post.
Case Type drives the questionnaire, the matter plan and every integration that creates an intake. Getting it wrong is the single most expensive mistake in a Litify build, because every report and automation downstream inherits 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.
Metric definitions, stage semantics and date fields get agreed during architecture, not improvised at the end. It is the difference between dashboards partners act on and dashboards they quietly stop opening.
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.
Litify is a legal practice and legal operations platform delivered as a managed package on Salesforce. The practical difference from a standalone legal system is that everything sits on the Salesforce platform: the same security and sharing model, the same reports and dashboards, the same Flow and Apex automation, the same API surface, and the whole AppExchange. That means your firm is never limited to what one vendor's roadmap decides to build — but it also means a Litify project is a Salesforce project, and needs to be staffed like one.
A focused implementation — core matter management, intake automation, billing setup and baseline reporting — typically runs 6 to 10 weeks. Engagements that add Litify AI configuration, external integrations or complex workflow logic take longer, and a migration from a system whose data was never clean can add several weeks on its own. We scope those separately and tell you which bucket you are in during discovery rather than at week six.
Case types, questionnaires, matter plans, task templates, billing rules, reports and dashboards are configuration — point-and-click work inside the package and inside Salesforce. Custom development starts where no configuration surface exists: a two-way integration with a system that has no connector, a screen that is not a record page, logic that has to run at volume, or an AI agent doing firm-specific work. The table in the "three ways we work" section above walks through the common cases row by row.
Almost never. Most struggling Litify orgs are technically live and operationally weak — the case type taxonomy was rushed, the matter plans do not match how the team works, automation was layered on without an execution order, or reporting was never given agreed definitions. That is repair work inside the existing org, and it keeps your history, your integrations and your users' logins. We only recommend a rebuild when the audit shows it is genuinely cheaper than the repair, and we show you the reasoning.
Yes. Because Litify is a Salesforce application, integration uses standard Salesforce APIs, AppExchange connectors and ordinary middleware rather than a proprietary gateway. Partner connectors exist for accounting systems including QuickBooks, Accounting Seed and Sage Intacct; DocuSign and Adobe Sign cover e-signature; iManage and NetDocuments cover document management for firms already standardised on a DMS. Where no connector exists we build the integration, and we design the error handling, retry and reconciliation with it — that part is what separates an integration that survives a year from one that quietly stops.
Usually not in the same phase. Litify ships named agents for intake qualification, conflict checking, matter summaries, damages work and invoice review, and Salesforce Agentforce can act over the same data — but every one of them reads the records your team creates. If case types are inconsistent or matter data is thin, an agent will confidently produce output nobody should act on. We assess AI readiness during discovery and usually sequence agents into the phase after go-live, once the data they depend on is trustworthy.
We do not sell Litify licenses — you license the platform directly from the vendor, and its pricing is published on the Salesforce AppExchange. Twopir Consulting is a Salesforce consultancy: we implement, configure and extend Litify, and we build the custom development around it on the Salesforce platform. That separation is deliberate. It means our recommendation about what you should configure, build or skip is not tied to what we would earn on the licence.
This page is the overview. Each service below goes into the detail a specific team needs — pick the one closest to the question you arrived with.
A first conversation is an architecture conversation: how your firm runs a case today, what Litify is doing about it now, and where configuration stops being enough. You will leave it knowing which of the three engagement modes you actually need.
Salesforce architects · Litify configuration · Custom development · Ongoing support
