How to run attorney fee calculations in DocketMath for New Hampshire

Step-by-step

Run this scenario in DocketMath using the Attorney Fee calculator.

This guide walks you through running attorney fee calculations in DocketMath for New Hampshire (US-NH) using the built-in attorney-fee calculator. You’ll enter the inputs, confirm the jurisdiction context, and interpret outputs in a way you can reuse for case planning and documentation.

1) Open the attorney-fee calculator in DocketMath

Start at the primary call-to-action:

• /tools/attorney-fee

If you already have a DocketMath project open, switch to the attorney-fee calculator view (the UI will typically show input fields and a results panel).

2) Confirm the jurisdiction is set to New Hampshire (US-NH)

In the calculator settings or jurisdiction dropdown, select:

• Jurisdiction: **New Hampshire (US-NH)

Why this matters: DocketMath uses the jurisdiction context to help you keep timing assumptions consistent when you document how/when something might be asserted.

3) Gather the fee inputs you’ll plug in

Before typing anything, collect the parts of your billing that will drive the calculation. For most attorney-fee workflows, you’ll need at least the following categories:

• Hourly rate(s) (e.g., $350/hour, or different rates by attorney/timekeeper)
• Hours worked (by task, attorney, or timekeeper)
• Any flat fees (if your billing includes them)
• Costs / expenses (only if the tool includes cost fields in your setup)
• Any adjustments (if the tool supports them—some calculators allow multipliers or reductions)

Tip: Use your billing records exactly as written. In practice, time entries and rate tables are often the most defensible “inputs” when you later explain how the numbers were produced.

4) Enter attorney fee components

Enter your time and rate information in the sections DocketMath provides.

Common entry patterns:

• Single-rate model: total hours × one hourly rate
• Multi-rate model: hours × rate for each attorney/timekeeper, then sum
• Task-based model: if the tool supports line items (e.g., “motion prep,” “hearing attendance”), add each line and let the calculator total

As you add line items, monitor the calculator’s results panel (for example, “Total fees”) so you can spot input errors early.

5) Choose whether you’re calculating “fees only” or “fees + costs”

Depending on your DocketMath setup, the calculator may let you include expenses.

A practical approach:

• For an initial settlement/demand exposure model, run fees only first.
• Then run a second version with costs enabled so you can compare fees vs. fees + costs.

6) Run the calculator and review the outputs

Click Calculate (or the equivalent button in DocketMath). Then review:

• Total attorney fees
• Total costs/expenses (if enabled)
• Grand total (fees + costs)
• Any intermediate subtotals (by line item or by timekeeper)

If DocketMath shows a breakdown by attorney/timekeeper or by line item, keep that view for documentation.

7) Add the New Hampshire timing context for documentation

New Hampshire’s general civil statute of limitations period is:

• RSA 508:4 (General SOL Period: 3 years)
  Source: https://www.thelaw.com/law/new-hampshire-statute-of-limitations-civil-actions.391/?utm_source=openai

Important constraint (use this clearly in your work):

• No claim-type-specific sub-rule was found for this workflow in the provided jurisdiction data. That means you should document “general/default SOL period” explicitly (not a specialized fee-related or claim-specific timing rule).

General/default period used in this guide:

• 3 years under RSA 508:4

How to use this in practice:
DocketMath helps you total the fees (math), but your documentation should also state the assumption that the timing context you’re using is the general 3-year default under RSA 508:4.

8) Record your assumptions alongside the numbers

Before exporting or saving results in DocketMath, capture the key facts that drive the outputs, such as:

• Which rates were used (and whether they match your engagement/billing schedule)
• Whether costs were included
• The time window covered by “hours worked”
• That your timing reference is the RSA 508:4 general 3-year period (and not a claim-specific exception)

This reduces confusion later when someone asks, “What exactly did you assume?” even if the arithmetic is correct.

Common assumption warning: A total fee figure can look precise while being legally incomplete if eligibility, reasonableness, or enforceability is disputed. Treat DocketMath outputs as calculation summaries, not legal conclusions.

Common pitfalls

Attorney-fee calculations usually go wrong due to input/assumption drift—not because the calculator can’t do the math. Use this checklist every time you run the attorney-fee calculator.

• using gross recovery when net applies
• mixing recoverable and non-recoverable time
• skipping statutory prerequisites
• forgetting fee caps or schedules

Input and modeling pitfalls to watch

• Incorrect hourly rates

  • Example: using a partner’s rate for an associate’s time entries
• Understating or overcounting hours

  • Example: double entries, missing billing increments, or including non-billable time
• Forgetting costs or adding them twice

  • Example: your billing includes expenses in one place, but you also type the same amounts into a “cost” field
• Using an average rate incorrectly

  • Especially if DocketMath expects line-item rate entries
• Not separating timekeepers

  • If different attorneys/timekeepers have different rates, totals can be distorted by blended inputs
• Applying the wrong limitations period for documentation

  • For this workflow, the guide uses RSA 508:4’s general 3-year default and documents it as such
• Assuming fee eligibility based on arithmetic

  • The calculator tells you the total; it doesn’t determine whether fees are legally recoverable

Timing documentation pitfalls (New Hampshire specific)

• Clearly document that the timing assumption is the default general SOL period:

  • RSA 508:4: 3 years
• Avoid implying a claim-type-specific SOL rule

  • The provided jurisdiction data did not include a claim-type-specific sub-rule for this workflow

Quick rule of thumb: If you can’t point to the basis for the timing assumption you used, write it down as a general/default assumption (as this guide does).

Try it

Ready to validate your workflow in DocketMath? Use this quick test scenario with your own values (or just to confirm the tool is behaving as expected).

Open the Attorney Fee calculator and follow the steps above: Run the calculator.

Quick test scenario (confirm the math flow)

1. Open /tools/attorney-fee
2. Set **Jurisdiction: New Hampshire (US-NH)
3. Enter two line items:

   • Line A: 6.5 hours at $300/hour
   • Line B: 2.0 hours at $450/hour
4. Leave costs off for the first run
5. Click Calculate
6. Confirm the outputs update to:

   • Line A: 6.5 × 300 = $1,950
   • Line B: 2.0 × 450 = $900
   • Fees total = $2,850

Then run a second calculation:

• Turn costs on (if available) and add $200 in expenses
• Confirm grand total becomes $3,050

Add the New Hampshire SOL note to your record

In your documentation notes (separately from the numeric fields), record something like:

• “Timing context uses the RSA 508:4 general 3-year SOL period (default), not a claim-type-specific rule.”

This ensures your record includes both:

• the numbers (from DocketMath), and
• the assumption (from the jurisdiction context used for documentation).

Related reading

• Worked example: attorney fee calculations in Vermont — Worked example with real statute citations
• Attorney Fees Guide for Alaska
• Attorney Fees Guide for American Samoa