How to run Settlement Allocator in DocketMath for Mississippi

Step-by-step

Use DocketMath’s Settlement Allocator to distribute a single settlement amount across eligible plaintiffs/claimants in a way that stays consistent with Mississippi (US-MS) workflow assumptions and DocketMath’s jurisdiction-aware rule set. This walkthrough focuses on running the calculator correctly, not on giving legal advice.

Before you start, gather what DocketMath needs:

• Total settlement amount (the single global figure you’re allocating)
• Payees / claimants list (each person/party to receive an allocation)
• Allocation basis values (the numbers you want the allocator to weigh—commonly damages-related figures or other negotiated weights, depending on your inputs)
• Any constraints you want reflected (for example, minimum/maximum caps per payee, if your workflow uses them)

Mississippi note (important): Mississippi has a general/default approach for the settlement allocation period because no specific class-action sub-rule was found in the referenced rule set for this guide. For the period logic and default allocation window, treat the calculation as applying the default general rule, not a special class-action rule.

Also, DocketMath’s Mississippi workflow is grounded in the Mississippi Rules of Civil Procedure, which you can review here: https://courts.ms.gov/rules/msrulesofcourt/. (General references only—this guide is about tool usage.)

1) Open the tool in DocketMath

• Go to the primary CTA: /tools/settlement-allocator

  • You should be on the Settlement Allocator page.
• Select the jurisdiction: Mississippi (US-MS)

If you’re working inside a docket or case workspace, you can often create a new calculation from there. The key step is ensuring the jurisdiction is set to US-MS before you enter amounts.

2) Add your payees/claimants

For each person/party you plan to allocate to:

• Click Add payee
• Enter the payee name (or ID) and the allocation basis value you’ll use for weighting.

A simple setup example:

Input consistency matters: keep the basis values in the same unit/scale across payees. If you mix different concepts (e.g., “estimated damages” for one payee but “already-negotiated settlement proportion” for another), the allocator may produce results that feel unintuitive—because it treats the basis values as weights.

3) Enter the total settlement amount

• In Total settlement, enter the exact global amount (for example, 250000)
• Confirm any currency/rounding settings if your interface includes them

After you run the tool, the sum of allocations should match your total (subject to the tool’s rounding approach).

4) Configure jurisdiction-aware settings for Mississippi

Set any options that affect how DocketMath treats procedure/scope for US-MS.

In this Mississippi guide, the workflow anchor is the civil procedure baseline reflected in the Mississippi Rules of Civil Procedure. The referenced jurisdiction note also states:

• No class-action sub-rule was found for the period logic used here, so the calculator should rely on the general/default period logic
• Where procedural modeling is needed, the guide’s note prefers joinder assumptions via Rule 20 rather than forcing a class-action framework

In practice, your UI may show toggles similar to:

• Default period / allocation window
• Scope of parties included
• Joinder assumptions

If you see multiple procedural-model choices, choose the option aligned with default/general logic rather than a class-action-specific model (because this guide’s jurisdiction note indicates no class-action sub-rule was found for the relevant period logic).

5) Run the allocation

• Click Calculate
• Review outputs, typically including:

  • Allocation per payee
  • Percent shares
  • Rounding differences (if the tool reports any remainder handling)

If results look off, don’t assume it’s “just rounding.” These calculators are deterministic: small input changes—especially changes to basis weights—can materially change the output distribution.

6) Export or save results for the record

When you’re satisfied with the run:

• Use Export (PDF/CSV depending on your UI)
• Save the calculation for auditability

Usually, you’ll want to retain:

• The total settlement used
• The payee list
• The basis values
• Any option selections tied to US-MS behavior

Common pitfalls

Mississippi-specific workflow issues usually come from using the wrong procedural framing or entering inconsistent values. Watch for:

• Using class-action assumptions when the referenced rule set supports default/general logic

  • This guide explicitly flags that no class-action sub-rule was found for the period logic referenced here.
  • Use the default/general period approach in the tool.

• Mixing incompatible basis values

  • Example: weighting one payee with “claimed damages” while another payee is weighted with “already negotiated amount.”
  • The allocator weights by what you enter—not what you intended.

• Forgetting to set jurisdiction to US-MS

  • If your UI remembers your last selection, it’s easy to accidentally run with the wrong jurisdiction.
  • Always confirm US-MS before calculating.

• Including payees unintentionally

  • If a payee is in the list, the allocator typically includes them in the weighting and will give them a share.
  • Remove any parties you don’t want allocated to.

• Rounding surprises

  • When amounts include cents or basis values have many decimals, rounding can cause a small mismatch from the exact total.
  • Check remainder handling—sometimes the tool assigns the remainder to a specific payee.

If outputs look “off,” start by verifying basis-value consistency across payees. In allocation calculators, the relative weights often matter more than the exact total.

Try it

Use this quick “sanity check” run in DocketMath to confirm the calculator is wired correctly (jurisdiction + input consistency) before using real numbers.

1. Open /tools/settlement-allocator
2. Set jurisdiction to Mississippi (US-MS)
3. Enter a test total settlement:

   • Example: 100000
4. Add 3 payees with consistent basis weights:

   • Payee 1: basis 60000
   • Payee 2: basis 25000
   • Payee 3: basis 15000
5. Click Calculate
6. Confirm expectations:

   • Percent shares should roughly follow the basis weights (~60% / 25% / 15%)
   • Allocations should sum to the total settlement, subject to rounding

Then test sensitivity by changing only one value:

• Change only Payee 2’s basis from 25000 to 20000
• Re-run and observe:

  • Payee 2’s allocation should decrease
  • Payee 1 and/or Payee 3 should increase depending on the tool’s remainder handling

If shares don’t move in line with basis changes, stop and re-check:

• jurisdiction selection (US-MS)
• whether one payee used a different metric
• any option toggles that affect the calculation model

Related reading

• How to calculate Settlement Allocator in Ohio — Full how-to guide with jurisdiction-specific rules
• How to calculate Settlement Allocator in Philippines — Full how-to guide with jurisdiction-specific rules
• Worked example: Settlement Allocator in Philippines — Worked example with real statute citations