Spreadsheet checks before running statute of limitations in Rhode Island

Running Rhode Island statute-of-limitations calculations from a spreadsheet can be fast—and dangerously easy to get wrong.

This post walks through how to sanity‑check your spreadsheet before you push anything into a Rhode Island statute-of-limitations calculator like DocketMath’s /tools/statute-of-limitations.

You’ll see:

• What the checker is looking for
• How Rhode Island–specific quirks affect your inputs
• A practical pre‑flight checklist you can reuse on every matter

What the checker catches

Think of a “spreadsheet checker” as a short, repeatable review you run on your data before you trust any deadline output.

Here’s what you want it to catch for Rhode Island statute-of-limitations work.

• Date ordering problems (end date before start date).
• Rates entered as whole numbers instead of percentages.
• Missing caps or discounts in the spreadsheet.
• Inconsistent rounding or day-count conventions.

1. Date sanity (no impossible or misaligned dates)

At a minimum, your checker should flag:

• Dates in the future that shouldn’t be (e.g., “injury date” next month)
• Dates before a plausible range (e.g., 1900) that are probably typos
• Text that looks like a date but isn’t being treated as one by Excel/Sheets
• Mixed formats that will break calculations (e.g., MM/DD/YYYY and DD/MM/YYYY in the same column)

Typical date columns for Rhode Island limitations work:

2. Jurisdiction alignment (Rhode Island vs. everything else)

When you’re running Rhode Island deadlines, the spreadsheet should make that explicit and consistent.

Your checker should confirm:

• Every row expected to use Rhode Island law is tagged US-RI (or a consistent RI code)
• No stray rows with US-MA, US-CT, or generic US that might be mis‑routed
• No missing jurisdiction codes where Rhode Island is assumed but not documented

Example layout:

Your checker can simply filter for anything not equal to US-RI in a Rhode Island‑only batch and force a human review.

3. Claim-type mapping (so the right Rhode Island rule is used)

Statute-of-limitations periods in Rhode Island depend heavily on the type of claim and sometimes on sub‑categories.

Your checker should verify that:

• Every row has a claim type (no blanks)
• Claim types are from a controlled list, not free‑form text
• Claim types are mapped to the right Rhode Island rule set in your calculator

For example, instead of letting people type anything, use a validation list like:

4. Accrual vs. incident vs. discovery dates

Rhode Island’s actual accrual rules can be nuanced. Your spreadsheet checker doesn’t decide what accrual is—that’s legal work—but it can enforce how you record it.

Checks to include:

• If accrual_date is blank, flag the row
• If discovery_date is filled but accrual_date is not, flag for review
• If accrual_date is earlier than incident_date in a context where that’s unlikely, flag it
• If a claim type is one where discovery rules might matter (e.g., medical_malpractice), ensure discovery_date is at least considered

A simple rule-of-thumb formula (Excel/Sheets) to flag odd timing:

=IF(AND(NOT(ISBLANK([@incident_date])),
        NOT(ISBLANK([@accrual_date])),
        [@accrual_date] < [@incident_date]),
   "Check timing",
   "")

This doesn’t say it’s wrong—it just forces a second look.

5. Tolling and extensions data

If you’re tracking tolling or extensions for Rhode Island matters, your checker should:

• Ensure tolling periods have both tolling_start and tolling_end
• Flag overlapping tolling periods for the same matter
• Confirm that tolling_end is not before tolling_start

Example overlap check (for a given matter with multiple rows of tolling):

• Sort by tolling_start
• Add a helper column: =IF(A2 <= B1, "Overlap", "") where A2 is current tolling_start and B1 is prior tolling_end

Your Rhode Island statute-of-limitations calculator (like DocketMath’s) will usually take:

• Accrual date
• Jurisdiction (US-RI)
• Claim type
• Any tolling periods

The quality of those inputs is what the spreadsheet checker is protecting.

When to run it

You’ll get the most value from a spreadsheet checker if you treat it as a standard step in your Rhode Island deadline workflow, not a one‑off.

Run the checker before importing a spreadsheet into the Statute Of Limitations workflow. It is especially helpful when you have multiple entries or when a teammate provided the inputs.

1. Right after data import or collection

Run the checker:

• After importing data from a case management system
• After paralegals or attorneys finish manual entry for a new batch
• Whenever you paste in data from an external spreadsheet or PDF extraction

At this stage, you’re looking for:

• Structural issues (wrong columns, missing columns)
• Obvious date or jurisdiction problems
• Claim-type mismatches

2. Before each statute-of-limitations batch run

Any time you’re about to send a block of Rhode Island matters through a tool like DocketMath’s statute-of-limitations calculator:

• Filter to jurisdiction_code = US-RI
• Run the checker on that filtered set
• Fix or comment on any flagged rows
• Only then, export or connect to the calculator

This keeps “bad rows” from polluting your deadline outputs or forcing you to re‑run entire batches.

3. After major rule or template changes

If you:

• Add a new Rhode Island claim type
• Change how you record accrual vs. incident dates
• Introduce or retire a tolling column

…run the checker on existing data to find rows that now fail your updated standards. That way, you don’t have old matters silently using outdated assumptions.

Try the checker

You can approximate a Rhode Island spreadsheet checker in three layers:

Upload the spreadsheet, review the warnings, and then run the calculation once the inputs are clean: Try the checker.

Capture the source for each input so another team member can verify the same result quickly.

Layer 1: Simple filters and conditional formatting

In Excel or Google Sheets:

• Apply filters to:

  • Show only blank accrual_date cells
  • Show any jurisdiction_code not equal to US-RI in a Rhode Island batch
  • Show any claim_type not in your approved list
• Use conditional formatting to:

  • Highlight dates that are clearly off (e.g., before 1980 or after today)
  • Flag tolling_end earlier than tolling_start

This is the fastest way to get started and works well for small teams.

Layer 2: A dedicated “Check” tab

Create a separate tab that pulls in your data and runs formulas to produce a status column like:

• OK
• Missing accrual date
• Unknown claim type
• Non-RI jurisdiction in RI batch
• Date anomaly – check

Example status formula (simplified):

=IF([@jurisdiction_code]<>"US-RI","Non-RI jurisdiction",
 IF(ISBLANK([@accrual_date]),"Missing accrual date",
 IF(ISNA(MATCH([@claim_type],ClaimTypes!$A$2:$A$20,0)),"Unknown claim type",
 "OK")))

Filter to anything not equal to OK before you run deadlines.

Layer 3: Pairing with DocketMath

Once your spreadsheet passes your internal checker, you can use DocketMath’s Rhode Island statute-of-limitations calculator to:

• Feed in:

  • jurisdiction_code (e.g., US-RI)
  • accrual_date
  • claim_type
  • Any tolling periods
• Get out:

  • A calculated last day to file under the rule set you’ve configured for Rhode Island

Related reading

• Spreadsheet checks before running deadlines in California

• Common interest mistakes in Rhode Island

• Choosing the right statute of limitations tool for Vermont

• Why we started the DocketMath blog