Worked example: Wage Backpay in Oregon

Example inputs

Run this scenario in DocketMath using the Wage Backpay calculator.

Below is a jurisdiction-aware worked example for calculating wage backpay in Oregon (US-OR) using DocketMath. This example is designed to show how the inputs map to outputs—so you can replicate the workflow with your own numbers.

Scenario (what happened)

• An employer failed to pay an employee for missed work shifts.
• The employee worked part-time in Oregon.
• The dispute covers 2 workweeks in the same quarter.
• The employer disputes hours, so you are calculating backpay from the employee’s documented schedule.

Key wage assumptions (use your own facts)

For this example, we’ll use:

• Regular hourly wage: $18.00/hour
• Overtime rate: not triggered in this scenario (see hours summary)
• Hours missed (documented):

  • Week 1: 22.0 hours
  • Week 2: 20.0 hours
• Pay period dates:

  • Week 1: 2024-03-04 to 2024-03-10
  • Week 2: 2024-03-11 to 2024-03-17

“Backpay” vs “damages” concept for this example

This walkthrough focuses on wages owed for missed hours (not attorney fees, not civil penalties, and not separate statutory liquidated damages unless your selected calculator mode includes them).

Inputs you would enter in DocketMath (wage-backpay)

Open the tool at /tools/wage-backpay.

Common inputs for a wage-backpay calculator run look like this:

• Jurisdiction: Oregon (US-OR)
• Wage type: hourly (regular wage basis)
• Base hourly wage: $18.00
• Hours by period:

  • 2024-03-04: 22.0
  • 2024-03-11: 20.0
• Overtime rule: auto (or “overtime not applicable” if hours stay below the threshold configured for the calculator run)
• Computation mode: “wage backpay” (not fringe benefits, not penalties)

If your version of the tool includes an optional interest setting, you can leave it off for the core “wages owed” number, then revisit interest separately in your sensitivity check.

Example run

Let’s run the numbers exactly in the structure DocketMath typically uses for wage-backpay.

Run the Wage Backpay 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 gross backpay per week

Week 1 backpay

• Hours: 22.0
• Rate: $18.00/hour
• Backpay: 22.0 × 18.00 = $396.00

Week 2 backpay

• Hours: 20.0
• Rate: $18.00/hour
• Backpay: 20.0 × 18.00 = $360.00

Step 2: Total wages owed (core output)

Total backpay:

• $396.00 + $360.00 = $756.00

So, the primary output for this example run is:

Step 3: Overtime screening (why overtime does not add here)

A key practical check is whether the hours cross an overtime threshold during either workweek. In this scenario:

• Week 1: 22.0 hours
• Week 2: 20.0 hours

Because the calculator is configured to apply overtime only when thresholds are exceeded (and because DocketMath treats this scenario as within the non-overtime band), no overtime differential is added.

Step 4: Payment offsets (if you used partial payment)

Some wage-backpay calculators include a “payments made” field to subtract amounts already paid. In this example run, we assume $0 was paid for the missed shifts.

If you add an offset, the output becomes:

• **Adjusted backpay = $756.00 − (payments already made for those exact hours)

To see where this matters, jump to the sensitivity check below.

How to run it in DocketMath

1. Go to /tools/wage-backpay
2. Set **Jurisdiction: Oregon (US-OR)
3. Enter:

   • Hourly wage: $18.00
   • Period dates: 2024-03-04 to 2024-03-17 (split into week totals as shown)
   • Hours: 22 and 20
4. Confirm overtime handling: should show no overtime adjustments
5. Review the computed total: $756.00

Sensitivity check

Small changes in inputs can swing wage-backpay totals. This section shows how.

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.

Sensitivity A: What if hours were overstated by 3 hours?

Assume the employee’s documentation was later revised:

• Week 1 hours decrease from 22.0 → 19.0
• Week 2 remains 20.0

Recompute:

• Week 1: 19.0 × 18.00 = $342.00
• Week 2: 20.0 × 18.00 = $360.00
• Total: $342.00 + $360.00 = $702.00

Impact: $756.00 − $702.00 = $54.00 decrease
Rule of thumb: every missed hour at $18.00 changes the total by $18.00 (when overtime doesn’t kick in).

Sensitivity B: What if the hourly rate differs (e.g., $19.50)?

Now assume the correct regular rate is $19.50/hour, with the original hours unchanged (22 and 20):

• Week 1: 22.0 × 19.50 = $429.00
• Week 2: 20.0 × 19.50 = $390.00
• Total: $429.00 + $390.00 = $819.00

Impact: $819.00 − $756.00 = $63.00 increase

Sensitivity C: What if one week crosses into overtime?

To illustrate overtime sensitivity, imagine Week 1 hours were actually 42 hours instead of 22.

DocketMath would then treat that workweek as overtime-eligible depending on the tool’s configured Oregon overtime logic.

Even without specifying the exact overtime multiplier in this brief, the practical effect is:

• regular wages apply to the base portion at the regular rate
• overtime differential applies to the excess hours

Action: In DocketMath, adjust only the week in question and watch the output line items change (regular vs overtime). If overtime appears, confirm that:

• the threshold is applied on a weekly basis, and
• hours are not double-counted across pay periods.

Sensitivity D: Partial payments already made

Suppose the employer made partial payment for those missed shifts—say $200 was already paid.

Using the base run total ($756.00):

• Adjusted backpay = $756.00 − $200 = $556.00

Impact: output drops dollar-for-dollar with the entered offset—so the credibility of your payment ledger matters.

Quick comparison table

Related reading

• Wage & Backpay Calculator Guide for Alabama
• Wage & Backpay Calculator Guide for Arizona
• Wage & Backpay Calculator Guide for Colorado