Worked example: Closing Cost in Indiana

Example inputs

Run this scenario in DocketMath using the Closing Cost calculator.

Below is a worked example showing how DocketMath (the closing-cost calculator) can be used to estimate closing costs for an Indiana transaction scenario. This walkthrough is about how the calculator behaves with jurisdiction-aware rules, not about providing legal advice.

Scenario (Indiana)

Assume a residential real estate closing in Indiana on:

• Close date: 2026-04-15
• Property value (purchase price): $220,000
• Down payment: $44,000
• Loan amount: $176,000
• Base closing costs (estimated): $3,250
• Prepaids/escrows (estimated): $1,450
• Title/settlement fees (estimated): $850

Because DocketMath is jurisdiction-aware, this example applies the Indiana default, statute-based limitation period used for the tool’s time-related logic.

Jurisdiction-aware timing rule used in this example (Indiana)

In this worked example, DocketMath’s jurisdiction-aware default uses the general SOL (limitation) period as follows:

• General limitation period: 5 years
• Indiana statute: Indiana Code § 35-41-4-2
• Source: https://law.justia.com/codes/indiana/2022/title-35/article-41/chapter-4/section-35-41-4-2/?utm_source=openai

Inputs summary (what you would enter)

You can think of these as the typical fields the closing-cost calculator needs—some are transaction-driven (price/loan), others are cost-driven (fees, prepaids).

Example run

Open DocketMath and use the Indiana setting (US-IN), then enter the scenario inputs above. The tool is here: /tools/closing-cost.

Run the Closing Cost 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 1: Compute core cost totals (cost inputs)

The calculator aggregates your provided cost components into a starting total.

• Base closing costs: $3,250
• Prepaids/escrows: $1,450
• Title/settlement fees: $850

Subtotal (non-time-adjusted):
$3,250 + $1,450 + $850 = $5,550

Step 2: Apply Indiana jurisdiction-aware time rule (default 5-year SOL)

DocketMath then applies the Indiana default limitation period—5 years—inside the tool’s jurisdiction-aware, timing-aware computation path (based on how the tool is designed to use the period internally).

For this example:

• Indiana default period: 5 years
• Statute: Indiana Code § 35-41-4-2
• Claim-type-specific adjustment: None in this run (the example uses the general/default period)

Warning / clarity point: If you’re expecting a different limitation period tied to a specific claim category, this example does not do that. This worked example intentionally uses only the general/default 5-year period because no claim-type-specific sub-rule was found for the calculator run.

Step 3: Output interpretation (what you should look at)

A closing-cost calculator typically returns one or more of the following:

• Estimated closing cost total
• A breakdown by category (if enabled)
• Any flags or notes that reference jurisdiction-aware logic

In this worked example, the primary total is driven by the provided cost inputs:

Estimated closing costs (Indiana run): $5,550
This reflects the sum of the input cost categories. The Indiana 5-year rule is used in DocketMath’s internal jurisdiction-aware logic, but the example’s displayed total is not changed by using the number as a dollar multiplier.

Output snapshot (how to record it)

When documenting your run, capture the input numbers and the specific jurisdiction rule used so your estimate is reproducible later:

If you want to sanity-check how the tool uses time windows in other contexts, start with the overall run on /tools/closing-cost, then compare outputs across scenarios while keeping the jurisdiction code (US-IN) constant.

Sensitivity check

Now adjust the inputs that most commonly change closing-cost estimates, while keeping the Indiana jurisdiction logic constant (default 5-year rule under Indiana Code § 35-41-4-2).

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.

What changes will affect the total the most?

In this example, closing costs are essentially driven by the sum of:

• Base closing costs
• Prepaids/escrows
• Title/settlement fees

Here, the 5-year period is part of the tool’s jurisdiction-aware timing logic, but the run’s total primarily moves when the fee buckets move.

Sensitivity scenario table

Keep all inputs the same except for one category at a time:

Timing-rule sensitivity check (Indiana)

For a timing-rule sensitivity check, you’d need the tool to apply a different limitation period than the general/default one.

In this worked example, DocketMath uses:

• 5 years, because it is the general/default limitation period
• Indiana Code § 35-41-4-2 is the cited statute for the general rule
• No claim-type-specific sub-rule was identified for this run, so you should not substitute another period unless the tool’s jurisdiction logic explicitly supports it for the scenario type you’re testing

Practical “what to log” checklist

To make your results easy to compare across reruns:

Related reading

• Average closing costs in Alabama — Rule summary with authoritative citations
• Average closing costs in Alaska — Rule summary with authoritative citations
• Average closing costs in Arizona — Rule summary with authoritative citations