FLSA Threshold Mapping

FLSA Threshold Mapping is the deterministic gate that resolves exempt versus non-exempt status before any gross-to-net calculation runs, and it sits inside the Core Architecture & Compliance Mapping for Payroll Systems framework as the classification authority every downstream overtime, accrual, and tax routine depends on. The Fair Labor Standards Act and its implementing regulations at 29 CFR Part 541 condition the white-collar exemptions on a salary-basis test, a salary-level test, and a duties test; a payroll engine that misaligns compensation records, geographic assignments, or effective dates against those statutory floors will silently under-pay overtime, mis-file wage statements, and accumulate misclassification liability that surfaces only under audit. This module consumes a jurisdiction, an effective date, and a normalized annual salary, and returns a single authoritative threshold with full traceability — treating each evaluation as a stateless, idempotent function so identical inputs always yield identical determinations regardless of retry or execution order.

Data Normalization & Boundary Enforcement

Raw HRIS exports rarely arrive in a calculation-ready state. Compensation components, pay frequencies, and location codes must be normalized before any threshold evaluation begins, and threshold mapping requires strict isolation of the salary-basis amount from bonuses, commissions, and other non-discretionary incentives. Under 29 CFR § 541.602 an exempt employee must receive a predetermined fixed salary “not subject to reduction because of variations in the quality or quantity of the work performed,” and 29 CFR § 541.601 permits only up to ten percent of the standard salary level to be satisfied by non-discretionary bonuses, incentive payments, and commissions paid at least annually. An ingestion layer that sums total compensation into the comparison value will over-state the salary basis and produce false exempt determinations.

Normalization pipelines must enforce the canonical-record contract defined in Data Boundary Definitions to keep schema drift, ambiguous location tags, and mixed compensation types from corrupting exemption logic. Boundary validation happens at the edge — before the determination engine ever sees a record — and quarantines anything that cannot be classified deterministically. Field-level constraints specific to FLSA mapping:

• Compensation component isolation. Every monetary field carries an explicit component type (BASE_SALARY, NON_DISCRETIONARY_BONUS, COMMISSION, DISCRETIONARY_BONUS). A record whose comparison value cannot be reduced to a clean salary basis is quarantined, never coerced.
• Pay-frequency annualization. Non-annual frequencies are annualized with deterministic multipliers (26 for biweekly, 24 for semi-monthly, 52 for weekly, 12 for monthly) applied before threshold comparison, never after. The multiplier is part of the canonical schema, not inferred at evaluation time.
• Jurisdictional identifier presence. A record without a resolvable primary-worksite location code cannot select a threshold and must not default to the federal floor. Quarantine it.
• Decimal currency precision. Salary values are stored and compared with Decimal precision rather than binary floating point, because the salary-level test is a hard step function: an employee at $43,888.00 versus $43,888.01 against a $43,888 floor produces a different statutory status, so accumulated IEEE-754 drift during annualization is a correctness defect, not a cosmetic one.

Annualization is the most error-prone normalization step. Expressed as a formula, the comparison value for a non-annual frequency is

$\text{salary}_{\text{annual}} = \text{salary}_{\text{period}} \times m_{\text{freq}}, \qquad m_{\text{freq}} \in \{52, 26, 24, 12\},$

and the multiplier must be selected from a fixed lookup keyed on the canonical frequency code — never derived from the count of pay dates in a calendar year, which varies (27 biweekly periods in some years) and would corrupt the basis.

Jurisdictional Resolution & Effective Dating

The federal salary level is the floor, not the whole rule. State and municipal statutes frequently impose higher salary floors for the white-collar exemptions — California ties its exempt salary threshold to twice the state minimum wage on a fixed annual schedule, New York sets distinct thresholds for New York City, Nassau/Suffolk/Westchester, and the remainder of the state, and Washington phases its multiplier of the state minimum wage upward each year. FLSA mapping therefore resolves rules with an explicit override hierarchy — Municipal > State > Federal — selecting the most protective applicable threshold for the employee’s primary worksite. The most protective standard is the highest salary floor, because a higher floor makes exemption harder to claim and protects the employee’s right to overtime.

Effective dating requires strict half-open window validation, so adjacent statutes never both match a single date:

SELECT annual_threshold
FROM flsa_thresholds
WHERE jurisdiction = :jurisdiction
  AND effective_start <= :evaluation_date
  AND (effective_end IS NULL OR :evaluation_date < effective_end)
ORDER BY precedence DESC, annual_threshold DESC
LIMIT 1;

Overlapping windows for the same jurisdiction indicate configuration drift and must be rejected at load time rather than silently tie-broken at evaluation time. The controlling rule is selected against the period being evaluated, never against today; inserting date.today() into a determination for a prior pay period is the single most common source of silently wrong classification history. This is the same temporal precision required by ACA Tracking Logic, where coverage eligibility turns on effective-dated measurement-period rules rather than a salary number; the date-window machinery is identical even though the dated artifact differs.

For deployments spanning multiple jurisdictions with conflicting municipal ordinances, the resolution hierarchy extends to evaluate nested geographic tiers — see Mapping FLSA thresholds for multi-state payroll for tiered override patterns and conflict-resolution matrices.

Production Implementation Pattern

The following implementation resolves a normalized compensation record against an effective-dated threshold registry. It uses decimal exclusively for monetary arithmetic, enforces half-open effective-date windowing with overlap detection at load time, applies the Municipal > State > Federal precedence, emits structured key=value logs that are copy-paste safe into production pipelines, and routes ambiguous or incomplete records to a quarantine queue instead of aborting the batch. The decision logic for what is recoverable versus blocking is shared with Fallback Routing Strategies, so threshold mapping reuses the same dead-letter and review-queue plumbing rather than inventing its own.

import logging
from dataclasses import dataclass
from datetime import date
from decimal import Decimal
from enum import Enum
from typing import Dict, List, Optional

logger = logging.getLogger(__name__)


class ResolutionStatus(str, Enum):
    EXEMPT = "exempt"
    NON_EXEMPT = "non_exempt"
    QUARANTINED = "quarantined"


@dataclass(frozen=True)
class ThresholdRecord:
    jurisdiction: str            # "US", "US-CA", "US-NY-NYC", ...
    effective_start: date
    effective_end: Optional[date]  # None == open-ended; window is [start, end)
    annual_threshold: Decimal
    precedence: int              # 0 federal, 1 state, 2 municipal


@dataclass(frozen=True)
class EmployeeCompRecord:
    employee_id: str
    location_code: str
    annual_base_salary: Decimal  # salary basis only, already annualized
    evaluation_date: date
    jurisdiction_override: Optional[str] = None


@dataclass(frozen=True)
class ResolutionResult:
    employee_id: str
    status: ResolutionStatus
    applied_threshold: Optional[Decimal]
    jurisdiction: str
    audit_message: str


class FLSAThresholdMapper:
    """Resolve exempt/non-exempt status against effective-dated thresholds.

    Pure and idempotent per record: identical inputs yield identical results.
    """

    def __init__(self, threshold_registry: List[ThresholdRecord]) -> None:
        self.registry = list(threshold_registry)
        self._validate_registry()

    def _validate_registry(self) -> None:
        """Reject overlapping effective windows within a jurisdiction at load time."""
        by_jur: Dict[str, List[ThresholdRecord]] = {}
        for rec in self.registry:
            by_jur.setdefault(rec.jurisdiction, []).append(rec)
        for jur, windows in by_jur.items():
            ordered = sorted(windows, key=lambda x: x.effective_start)
            for curr, nxt in zip(ordered, ordered[1:]):
                if curr.effective_end is None or nxt.effective_start < curr.effective_end:
                    raise ValueError(f"overlapping_windows jurisdiction={jur}")

    def resolve(self, record: EmployeeCompRecord) -> ResolutionResult:
        if record.annual_base_salary <= Decimal("0.00"):
            return self._fallback(record, "non_positive_salary")

        jurisdiction = record.jurisdiction_override or record.location_code
        if not jurisdiction:
            return self._fallback(record, "missing_jurisdiction")

        # Most-protective applicable threshold: federal floor plus any worksite override.
        candidates = [
            t for t in self.registry
            if t.jurisdiction in ("US", jurisdiction)
            and t.effective_start <= record.evaluation_date
            and (t.effective_end is None or record.evaluation_date < t.effective_end)
        ]
        if not candidates:
            return self._fallback(record, f"no_active_threshold jur={jurisdiction}")

        # Highest precedence wins; among those, the highest (most protective) floor.
        active = max(candidates, key=lambda t: (t.precedence, t.annual_threshold))

        is_exempt = record.annual_base_salary >= active.annual_threshold
        status = ResolutionStatus.EXEMPT if is_exempt else ResolutionStatus.NON_EXEMPT
        logger.info(
            "flsa_resolved emp=%s status=%s jur=%s salary=%s threshold=%s",
            record.employee_id, status.value, active.jurisdiction,
            record.annual_base_salary, active.annual_threshold,
        )
        return ResolutionResult(
            employee_id=record.employee_id,
            status=status,
            applied_threshold=active.annual_threshold,
            jurisdiction=active.jurisdiction,
            audit_message=(
                f"salary={record.annual_base_salary} "
                f"{'meets' if is_exempt else 'below'} "
                f"threshold={active.annual_threshold}"
            ),
        )

    def _fallback(self, record: EmployeeCompRecord, reason: str) -> ResolutionResult:
        logger.warning("flsa_quarantine emp=%s reason=%s", record.employee_id, reason)
        return ResolutionResult(
            employee_id=record.employee_id,
            status=ResolutionStatus.QUARANTINED,
            applied_threshold=None,
            jurisdiction=record.jurisdiction_override or record.location_code or "UNKNOWN",
            audit_message=f"quarantined reason={reason}",
        )

The salary-level test is necessary but not sufficient for exemption: 29 CFR § 541.700 still requires a duties test, and highly compensated employees fall under the separate total-annual-compensation standard of 29 CFR § 541.601. A production engine treats the salary comparison above as a gate that can establish non-exempt status definitively (a salary below the floor is non-exempt regardless of duties) but routes salary-passing records that lack a recorded duties determination to review rather than auto-flagging them exempt.

Compliance Verification & Fallback Routing

Audit readiness requires deterministic logging of every evaluation. Each ResolutionResult is persisted to an append-only ledger with the exact evaluation date, applied threshold, precedence, and jurisdictional context; in-memory state is never the source of truth for compliance reporting. Before any determination feeds gross-to-net, the pipeline runs a fixed verification checklist, and each item is a hard gate:

1. Unit boundary testing. Validate that annual_base_salary == threshold returns EXEMPT. The salary floor is a minimum, so meeting it exactly qualifies under the salary-level test; run fixtures at threshold - 0.01, threshold, and threshold + 0.01 and assert NON_EXEMPT, EXEMPT, EXEMPT.
2. Effective-date drift. Re-resolve the controlling threshold for a prior pay period and assert it returns the rule in force then, not the current one. Inject records with evaluation_date exactly on a threshold change date to confirm the half-open window selects the new rule on its start date and the old rule the day before.
3. Override precedence. With a federal, a state, and a municipal threshold all active for one worksite, assert the resolver selects the highest precedence and, among ties, the highest floor — and that a worksite with no state/municipal override correctly falls back to the federal floor.
4. Fallback activation. Deliberately strip jurisdiction codes, inject non-positive salaries, and load an overlapping threshold window; assert the first two quarantine the record while the batch completes, and the third raises at load time.
5. Decimal precision. Assert no value in the determination path is a float. Verify annualization uses the fixed frequency multiplier (not a pay-date count) and that comparisons happen against Decimal operands. Reference the Python Decimal documentation for context configuration.

When resolution returns QUARANTINED, the pipeline halts downstream gross-to-net processing for the affected record, routes it to a manual review queue, and emits a compliance alert; a degraded upstream feed must never silently classify a population as exempt. Final verification cross-references mapped thresholds against the U.S. Department of Labor Fact Sheet #17G: Salary Basis Requirement and applicable state labor codes, and a quarterly reconciliation ingests updated statutory limits before their effective dates trigger.

Failure Modes & Gotchas

• Float-stored salary. Storing or annualizing salary as float lets binary rounding move a true $43,888.00 to $43,887.9999…, flipping an employee from exempt to non-exempt at the boundary. Fix: Decimal end-to-end, with a type assertion at the determination boundary and a lint rule banning float in the mapping modules.
• Counting bonuses into the salary basis. Summing non-discretionary bonuses or commissions into the comparison value over-states the basis and produces false exempt determinations, because 29 CFR § 541.601 caps the non-discretionary contribution at ten percent of the standard level. Fix: isolate BASE_SALARY as the comparison value and apply the ten-percent allowance explicitly only where the plan documents support it.
• date.today() in a prior-period determination. Resolving the threshold against the current date silently re-classifies closed history when a statute changes (e.g. California’s annual step-up). Fix: effective-dated resolution keyed on evaluation_date, with overlapping windows rejected at load time.
• Pay-date-count annualization. Deriving the annual figure from the number of pay dates in the calendar year double-counts the 27th biweekly period in leap-aligned years and corrupts the basis. Fix: a fixed frequency-multiplier lookup (52/26/24/12) stored in the canonical record.
• Defaulting a missing jurisdiction to federal. Treating an absent location code as “US” applies the federal floor to an employee who may sit under a far higher state threshold, under-classifying them as exempt. Fix: quarantine records with no resolvable primary-worksite code; never default.

Frequently Asked Questions

Related

• Mapping FLSA thresholds for multi-state payroll — tiered override patterns and conflict-resolution matrices for employees spanning multiple jurisdictions.
• Data Boundary Definitions — the canonical-record contract and Decimal-precision boundaries enforced before threshold comparison.
• ACA Tracking Logic — effective-dated measurement-period resolution that shares this page’s date-window machinery.
• Fallback Routing Strategies — the quarantine, dead-letter, and review-queue routing reused by the resolver.
• Core Architecture & Compliance Mapping for Payroll Systems — the parent architecture this classification gate plugs into.

External Compliance References

• U.S. Department of Labor Fact Sheet #17G: Salary Basis Requirement
• 29 CFR § 541.600 — Amount of salary required
• 29 CFR § 541.601 — Highly compensated employees
• 29 CFR § 541.602 — Salary basis
• Python Decimal documentation