How to calculate Settlement Allocator in United States Federal

Quick takeaways

• A settlement allocator in United States Federal practice is a jurisdiction-aware computation that translates a single settlement amount into component amounts (e.g., damages vs. interest vs. fees/costs), based on how claims were pleaded and how the settlement is documented.
• In DocketMath, the settlement-allocator tool produces a breakdown by applying rules tied to the deal structure (global vs. claim-by-claim), allocation categories, and federal reporting considerations.
• The most common allocation failures come from missing payee/claim mappings, ignoring exclusions (like costs that may be handled separately), or misclassifying statutory amounts.
• If your settlement documents specify an allocation (or a methodology), you can usually model that directly in DocketMath; if they don’t, the federal workflow still depends on the intended basis (claims-based allocation vs. formula-based allocation).

Inputs you need

Before you open DocketMath → settlement-allocator, gather the inputs that let the calculator remain “jurisdiction-aware” for US-FED. The tool is only as accurate as the allocation structure you provide.

Use this intake checklist as your baseline for Settlement Allocator work in United States Federal.

• jurisdiction selection
• key dates and triggering events
• amounts or rates
• any caps or overrides

If any of these inputs are uncertain, document the assumption before you run the tool.

1) Settlement-level inputs

• Total settlement amount (numeric, and whether it’s gross or net of fees/costs)
• Settlement date (used to anchor timing-related components if you model them)
• Settlement type

  • ✅ Global settlement (single amount covering multiple claims/parties)
  • ✅ Claim-by-claim settlement (amounts already separated in the agreement)
  • ✅ Mixed (some amounts specified, some lumped)

2) Allocation categories (the buckets)

Decide what you want the allocator to output. Common categories for US-FED calculations include:

• Compensatory damages (principal recovery)
• Pre-judgment interest (if the settlement mentions interest or a methodology)
• Attorney’s fees
• Costs (court costs / litigation costs)
• Other components (e.g., statutory amounts explicitly stated)

In DocketMath, these categories become the columns of your allocation output.

3) Claim mapping (who/what the settlement covers)

For each claim or payee you plan to allocate:

• Claim identifier (e.g., “Count 1 – negligence”, “Federal claim for overtime”)
• Payee (plaintiff, class member, intervenor, assignee, etc.)
• Basis weight (how DocketMath should distribute the bucket)

  • Typical inputs:

    • pleaded damages amounts
    • negotiated “market” or “valuation” figures
    • number of units (e.g., workweeks) if your agreement uses unit pricing
    • proportionate shares (percentages)
• Inclusion/exclusion flag (does this claim participate in a category?)

4) Deal terms that drive federal rules

Provide any deal terms that affect categorization:

• Does the agreement include a stated allocation?

  • If yes: use it as the target allocation driver.
  • If no: you’ll likely rely on your chosen methodology (e.g., proportionate pleaded damages).
• Attorney’s fees handling

  • Are fees inside the settlement amount or paid separately?
• Cost treatment

  • Are costs carved out, reimbursed separately, or included in the lump sum?

5) Output preferences

Do you want output by:

• Payee (who receives what), or
• Claim (how each count is valued), or
• Both (more detailed, but requires more mapping)

How the calculation works

DocketMath’s settlement-allocator (US-FED) follows a consistent sequence: normalize, map, allocate, and reconcile.

DocketMath applies the United States Federal rule set to the inputs, then runs the calculation in ordered steps. It validates the trigger date, applies rate or cap logic, and produces a breakdown you can audit. If you change any one variable, the tool recalculates the downstream outputs immediately.

Step 1: Normalize the settlement total

If the settlement amount is provided as “gross,” but fees/costs are carved out, DocketMath will compute:

• Allocable base = Total settlement − excluded components (if you indicate exclusions)

Use this logic to prevent “double counting” across categories.

Step 2: Determine category drivers

For each allocation category (damages, interest, fees, costs), the tool determines a driver:

• Stated allocation driver (agreement specifies amounts)
• Proportionate driver (allocation is based on relative weights)
• Formula/unit driver (allocation by units, rate × units, or similar)

For example, if your agreement doesn’t specify interest but indicates it will be calculated separately, you can:

• allocate $0 to pre-judgment interest, or
• input an interest methodology amount if your settlement includes it.

Step 3: Allocate each category across claims/payees

For a given category, DocketMath computes:

1. Sum all active claim weights for that category
2. Compute each claim’s share:

   • Share% = claim_weight / total_active_weight
3. Apply share% to the category amount:

   • category_amount_to_claim = Share% × category_total

This is where your claim weights and inclusion flags matter most. If one claim is excluded from fees, it should be excluded from the fee bucket, not just excluded at the end.

Step 4: Reconcile to ensure totals match

A correct allocation should reconcile to the settlement structure you entered:

• Category totals sum back to the settlement (or allocable base)
• Claim-level allocations sum back to each category total
• Fee/cost treatment remains consistent with your inputs (“inside” vs. “paid separately”)

DocketMath can highlight when allocations don’t reconcile—most often due to rounding or inconsistent exclusions.

Example: what changes when you alter inputs

Here’s a simplified scenario to show how outputs move in DocketMath.

Settlement structure (US-FED)

• Total settlement amount: $1,000,000
• Fees paid inside settlement
• Costs excluded (reimbursed separately)
• Allocation categories: damages + interest + fees

Claim weights (for damages)

Category totals you provide

• Damages total: $850,000
• Pre-judgment interest total: $50,000
• Attorney’s fees total: $100,000

Now change one input: exclude Claim B from interest.

Result: the $50,000 interest is allocated 100% to Claim A, and DocketMath recalculates the claim-level split for the interest column while leaving damages unchanged (assuming damages inclusion flags didn’t change).

This illustrates the key operational rule: each category has its own inclusion map and driver.

Common pitfalls

Even experienced teams hit predictable issues when calculating a US-FED settlement allocator in a tool like DocketMath. Watch for these.

• Damages weights don’t automatically control interest, fees, or costs.
• If you mark fees as separate but also include them in the total amount, DocketMath will over-allocate.
• If a claim doesn’t participate in attorney’s fees under your documented approach, exclude it in the fee inclusion flag, not just by editing the final numbers.
• Allocations should sum correctly to the category totals and settlement total you entered.
• If they don’t, the issue is usually rounding or inconsistent inputs.
• If your agreement distinguishes statutory amounts from general damages, but you only allocate into “damages,” you lose the structure needed for accurate reporting-oriented outputs.
• Federal practice varies by claim type and deal language, so DocketMath needs your jurisdiction-aware mapping rather than a generic split.

Sources and references

No external sources were required for this operational guide. The workflow described reflects typical settlement allocation modeling practices and the importance of aligning deal terms (inside vs. outside fees/costs, and any stated allocation methodology) with the calculator inputs.

Start with the primary authority for United States Federal and confirm the effective date before relying on any output. If the rule has been amended, update the inputs and rerun the calculation.

• Primary authority reference

Next steps

1. Open DocketMath → settlement-allocator.
2. Choose your settlement type (global, claim-by-claim, mixed).
3. Define allocation categories you want in the output (damages, interest, fees, costs, other).
4. Enter claim/payee weights and set inclusion flags per category.
5. If your settlement agreement includes an explicit allocation, input it as the category totals (or driver) so the allocator matches the documented method.
6. Run the calculation and verify:

   • totals reconcile at the category level
   • totals reconcile at the claim/payee level
7. Export or capture the output and compare it to the settlement documentation’s allocation approach (especially how fees/costs are treated).

If you need to start with the tool right away, use the primary CTA: /tools/settlement-allocator.

Related reading

• Settlement Allocator Guide for Alabama
• Settlement Allocator Guide for Arizona
• Settlement Allocator Guide for Colorado