Worked example: Damages Allocation in Philippines

Example inputs

Run this scenario in DocketMath using the Damages Allocation calculator.

Below is a worked example showing how DocketMath (tool: /tools/damages-allocation, jurisdiction PH) can allocate damages across common buckets under Philippine civil liability concepts. This is a demonstration of calculations and workflow, not legal advice.

Scenario (fictional but realistic)

On 15 March 2026, Company A’s delivery driver (insured by Auto Insurance Co.) negligently rear-ends Company B’s truck at a city intersection. The collision causes:

• Property damage to Company B’s truck (repair costs).
• Transportation/operations loss during repairs.
• Medical expenses for the driver who sustained minor injuries (claimed by an injured person, but the injured person’s expenses are being tallied into the overall claim).
• Moral damages requested because the claimant alleges emotional distress due to the accident.

We’ll allocate an overall “claim damages pool” into categories that DocketMath can handle.

Parties and inputs (what you’d enter)

Assume you’re preparing an allocation estimate for one claim file.

1) Liability allocation (comparative fault)

DocketMath uses a fault split to allocate damages between responsible and non-responsible parties (where applicable).

• Driver fault (Company A / insured): 70%
• Other party fault (Company B): 30%

2) Damage buckets (gross amounts before fault allocation)

Use these amounts as the gross claimed damages pool (before applying 70/30):

Total claimed damages pool (gross): 860,000 PHP

3) Optional caps / conditions

For this example, we’ll include a condition often modeled in calculators: apply fault split to all buckets (not only economic damages). In DocketMath’s damages-allocation workflow, that’s a toggle or a rule selection—here we assume:

• Apply comparative fault to all buckets: Yes

4) Payment constraint (policy/collection modeling)

If you also track expected collection under a policy limit, DocketMath can model it. For the example:

• Insurance policy limit available for this claim: PHP 500,000
• No deductible modeled in this simple run (keep it 0 for clarity)

This introduces a second step: allocation and then a “payable under limit” cap.

Example run

Open DocketMath here: /tools/damages-allocation.

In your run, select jurisdiction PH and enter:

Run the Damages Allocation calculator using the example inputs above. Review the breakdown for intermediate steps (segments, adjustments, or rate changes) so you can see how each input moves the output. Save the result for reference and compare it to your actual scenario.

Step A — Allocation by fault

With:

• Fault(A) = 70%
• Fault(B) = 30%
• Gross buckets:

  • Property: 480,000
  • Operations loss: 120,000
  • Medical: 60,000
  • Moral: 200,000

DocketMath computes “responsible share”:

Key result: Company A’s fault share totals PHP 602,000.

Step B — Apply insurance/payout limit (if enabled)

You specified an available policy limit of PHP 500,000.

DocketMath then models payable allocation by applying the limit to the responsible party’s share. A common approach in calculators is proportional reduction across buckets so that the total payable equals the limit.

Responsible share is 602,000, but limit allows 500,000.

Reduction factor = 500,000 / 602,000 ≈ 0.83056

So DocketMath scales each bucket within Company A’s responsibility:

Step C — Output summary (what you’d record)

DocketMath’s output would typically include:

• Fault-allocated totals (who owes what before limits)
• Capped/payable totals (what is likely collectible given policy limit)
• Per-bucket breakdown for reporting and case timeline decisions

For this run:

• Company A (70%) before cap: PHP 602,000
• Payable under policy limit: PHP 500,000
• Company B (30%) before cap: PHP 258,000

If you’re preparing a demand or internal evaluation, these numbers give a structured starting point for settlement discussion.

Where jurisdiction-aware rules show up (PH)

In Philippines civil claims, the practical workflow usually requires you to separate:

• Economic damages (e.g., repair costs, medical expenses, actual losses)
• Non-economic damages (e.g., moral damages when recognized by law and pleaded)

DocketMath doesn’t replace pleading strategy, but it helps keep categories distinct so that jurisdiction-aware toggles (like whether moral damages are included in the fault-apportionment rule) can be reflected in the arithmetic.

Sensitivity check

Small changes in inputs can move the outcome. Here are three controlled variations and how outputs change in DocketMath.

To test sensitivity, change one high-impact input (like the rate, start date, or cap) and rerun the calculation. Compare the outputs side by side so you can see how small input shifts affect the result.

1) Fault split sensitivity (70/30 → 60/40)

Change only fault:

• Company A fault: 60%
• Company B fault: 40%
• Keep all gross buckets the same (860,000)
• Keep policy limit 500,000

Fault-allocated totals:

• Company A share = 60% × 860,000 = 516,000
• Company B share = 40% × 860,000 = 344,000

Now apply the cap:
Reduction factor = 500,000 / 516,000 ≈ 0.9690

Expected result:

• Company A payable becomes essentially close to the full 516,000, but reduced to 500,000.
• Per-bucket payable amounts remain proportional, but each bucket increases relative to the 70% case because the capped amount is closer to the responsibility total.

2) Moral damages included vs. excluded from fault allocation

In some modeling approaches, users choose whether moral damages are apportioned the same way as economic damages. Toggle:

• Keep fault at 70/30
• Keep policy limit at 500,000
• Model choice: Apply comparative fault to moral damages: No

DocketMath would compute economic buckets (property + operations + medical) under 70%, while moral damages might be treated under a different rule for estimation. To illustrate the arithmetic impact:

Economic gross = 480,000 + 120,000 + 60,000 = 660,000
Company A fault share (70%) = 462,000

Moral damages (200,000) may be either:

• Allocated differently, or
• Treated as full under the responsible party for estimation purposes, depending on the calculator’s rule.

This single toggle can meaningfully change whether the cap reduces moral damages or mostly reduces economic buckets.

3) Policy limit sensitivity (500,000 → 650,000)

Keep fault at 70/30 and include all buckets under fault allocation, but change policy limit to:

• PHP 650,000

Since Company A share before cap is 602,000, a 650,000 limit means no cap reduction occurs.

• Company A payable = 602,000
• Bucket payables equal the fault-allocated figures:

  • Property: 336,000
  • Operations loss: 84,000
  • Medical: 42,000
  • Moral: 140,000

This sensitivity is often the fastest way to see whether the case economics are driven by liability or by collectability.

Related reading

• Damages Allocation Guide for Alabama — Comparative Fault Rules
• Damages Allocation Guide for Alaska — Comparative Fault Rules
• Damages Allocation Guide for American Samoa — Comparative Fault Rules