Why deadlines results differ in Canada

When two lawyers in Canada run the “same” deadline and get different answers, it’s almost never because the math is random. It’s because one or more hidden inputs are different.

This post is a quick diagnostic you can use any time your DocketMath deadline result in Canada doesn’t match what someone else is seeing (or what you expected).

The top 5 reasons results differ

Here are the most common culprits, in order of how often they cause confusion.

• Different trigger dates or event definitions were used.
• Inputs were entered with different day-count or compounding assumptions.
• Payments, credits, or tolling periods were handled differently.
• Jurisdiction or court settings did not match the matter.
• Rounding or cutoff-time rules were applied inconsistently.

1. Wrong jurisdiction or level of court

In Canada, “jurisdiction” is not just country. It’s:

• Federal vs provincial/territorial
• Within a province: specific court or tribunal
• Sometimes: specific set of rules within the same court

Common mix‑ups:

• Federal Court vs Ontario Superior Court
• BC Supreme Court Civil Rules vs Family Rules
• Appeals vs first‑instance rules

Each of these can have different:

• Counting methods (clear days vs ordinary days)
• Treatment of weekends and holidays
• Trigger events (service vs filing)

If you and your colleague aren’t using the exact same jurisdiction setting in DocketMath, your dates will diverge.

2. Different “trigger” event and starting point

Most deadlines are expressed relative to an event:

• “Within 30 days after service of the statement of claim”
• “At least 10 days before the hearing”
• “No later than 2 days before…”

If you start counting from:

• The wrong event (e.g., filing date instead of service date), or
• The wrong interpretation of that event (e.g., date of electronic service vs date deemed served),

you’ll land on a different date even if the rule is the same.

Key distinctions that change outcomes:

• “After” vs “from” vs “following” a date
• “At least X days before” vs “no later than X days after”

3. Calendar vs business days (and how weekends/holidays are treated)

Not all “days” are equal:

• Calendar days: count every day, including weekends and holidays
• Business days: skip weekends and sometimes holidays
• Clear days: exclude the trigger day and the last day

Canadian rules vary:

• Some provincial rules treat weekends differently for short deadlines (e.g., less than 7 days).
• Some deadlines that end on a holiday are pushed to the next business day; others are not.

If one calculation assumes:

• “30 calendar days” and
• another assumes “30 days, excluding holidays, with end‑date adjustment”

you’ll get different answers.

4. Holiday calendars that don’t match reality

Holiday logic in Canada can be tricky:

• Federal vs provincial statutory holidays
• Court‑specific closure days
• “Observed” holidays when the statutory date falls on a weekend

If:

• Your colleague is using a court’s actual closure calendar, and
• You’re using only federal stat holidays,

your end date may fall on a day the court is closed in one calculation but not the other.

DocketMath’s Canada deadline calculations use jurisdiction‑specific holiday sets, but:

• A mismatch can still occur if someone is:

  • Using a different tool, or
  • Applying a different year’s holiday pattern, or
  • Manually overriding a date without documenting why.

5. Interpretation choices and local practice

Even with the same rule, lawyers sometimes make different, good‑faith interpretation choices, such as:

• Whether to treat a rule as “clear days” when the wording is ambiguous
• How to handle deemed service rules (e.g., mail vs email vs fax)
• Whether to follow strict rule text or local practice that “everyone uses”

Two common examples:

• One person applies deemed service + 5 days for mail; the other uses the actual receipt date.
• One person builds in an internal buffer (e.g., “treat 30 days as 28”); the other does not.

How to isolate the variable

When two Canadian deadline results don’t match, work through these steps in order. Treat it like debugging code.

• Freeze the jurisdiction and tool settings so both runs use the same rule set.
• Compare one input at a time (dates, rates, amounts) and re-run after each change.
• Review the breakdown to see which segment or assumption drives the difference.

1. Confirm you’re in the same jurisdiction

In DocketMath’s deadline calculator:

1. Open the matter or calculation.
2. Check:

   • Country: Canada
   • Province/territory (if applicable)
   • Court level and division
3. Ensure the other person is using exactly the same settings.

If you’re not sure which court rules apply, that’s a legal interpretation question—flag it rather than trying to “average” between options.

2. Line up the triggering event

Compare, in plain language:

• What event you used (e.g., “personal service of statement of claim on defendant”)
• The exact date you entered for that event
• Any deemed service rules you applied

Then confirm explicitly that you and the other person are using:

• The same event
• The same event date
• The same approach to deemed service

If any of those differ, you’ve likely found the cause.

3. Compare day‑counting settings

In DocketMath, look at:

• Day type: calendar days vs business days
• Whether the trigger day is included or excluded
• Whether the last day is adjusted if it falls on a weekend/holiday

Ask the other person:

• “Are you counting calendar days or business days?”
• “Do you include the day of service in your count?”
• “If the deadline falls on a holiday, do you move it to the next business day?”

Often, one of these answers differs.

4. Check holiday and closure assumptions

If the discrepancy is 1–2 days, it may be a holiday issue.

• Look at the year in question.
• Check whether:

  • A statutory holiday was observed on a different weekday.
  • The court had an extra closure day (e.g., storm day, special closure).

If you know the court was closed on a particular date, but your tool treated it as open, document that override clearly in your file.

5. Surface interpretation choices

When all the technical settings match but the dates still differ, you’ve hit an interpretation issue.

Examples to discuss explicitly:

• “Are you treating this as clear days?”
• “Are you counting from the date of service or the date deemed served?”
• “Are you building in internal safety buffers?”

Write down both interpretations, then record which one your team decides to adopt for the file.

Next steps

Once you’ve found the variable that’s causing the mismatch, you can:

1. Align on the correct rule

   • Confirm which court and rule set govern the deadline.
   • Treat any uncertainty as a legal issue to be resolved, not a math problem to be fudged.

2. Lock in your assumptions in DocketMath

   • Use the deadline calculator at /tools/deadline.
   • Save the matter with:

     • Jurisdiction and court
     • Trigger event and date
     • Any deemed service assumptions
     • Notes on interpretation choices

3. Document the rationale

   • In your file, record:

     • The rule citation
     • How you counted days
     • Any holidays or closures you accounted for
     • Any internal buffers (if used)

4. Standardize for your team

   • Turn recurring interpretation choices into:

     • Written guidelines
     • Templates or checklists
   • Use DocketMath to apply those consistently across files.

5. Treat the tool as a calculator, not a decision‑maker

   • DocketMath can help you calculate and document deadlines.
   • It does not decide which rule or interpretation is correct for your matter—that’s a legal judgment call.

If you’re repeatedly seeing differences in a specific Canadian court or rule set, that’s a signal to:

• Re‑read the rule text, and
• Tighten your team’s written guidance on how to apply it.

For a deeper look at how to structure and document your calculation inputs across jurisdictions, see our workflow post: /blog/jurisdiction-aware-calculation-workflow.

Related reading

• A practical workflow for jurisdiction‑aware legal calculations (and how to document them)

• Why we started the DocketMath blog

• Why we started the DocketMath blog