# Off The Pace  • docs

- [Off The Pace: F1 Lap Decomposition Analytics](https://offthepace.mintlify.app/index.md): Every F1 lap split into seven physically-grounded components, served by a fully client-side pipeline: FastF1 ingestion, dbt + DuckDB transforms, XGBoost models exported to ONNX, and a React app that runs entirely in the browser.
- [Engineering highlights: what a reviewer should notice](https://offthepace.mintlify.app/engineering-highlights.md): The eight things a senior reviewer should clock in sixty seconds: a CI-enforced invariant, a medallion warehouse, zero-server economics, train/serve parity, drift gates, out-of-sample honesty, and IaC. Each with one-line proof and a link to the evidence.
- [About: skills demonstrated and the builder behind Off The Pace](https://offthepace.mintlify.app/about.md): Off The Pace mapped to concrete data-engineering competencies, each linked to its evidence in the repo: data modelling, data contracts, orchestration, ML engineering, CI/CD, IaC, observability, and cost.
- [System design: architecture, the build-time vs request-time split, and trade-offs](https://offthepace.mintlify.app/system-design.md): The end-to-end architecture of Off The Pace in one place: component responsibilities, the medallion mapping, why heavy compute is pushed to CI and the client, and the trade-offs accepted on purpose.
- [How this clears a production data-engineering bar](https://offthepace.mintlify.app/data-engineering.md): The data-engineering checklist a hiring manager grades on, each item met by a real artifact in Off The Pace: idempotent ingestion, data contracts and a testing pyramid, drift and quality gates, lineage, orchestration, observability, SLOs, and a zero-server cost model.
- [Key Concepts: the vocabulary used throughout these docs](https://offthepace.mintlify.app/key-concepts.md): A high-level orientation to pace delta, the seven decomposition terms, the tyre cliff, and structural pace as used throughout the Off The Pace docs and app.
- [Glossary of F1 analytics and lap decomposition terms](https://offthepace.mintlify.app/reference/glossary.md): Definitions for every F1 domain term, decomposition component, tyre model concept, and ML metric used throughout the Off The Pace documentation.
- [Attributed findings: race decompositions with evidence](https://offthepace.mintlify.app/findings/overview.md): Real race analyses where the seven-term decomposition produces precise, verifiable answers from actual historical F1 data not a theoretical model.
- [São Paulo 2021: strategy vs driver skill, decomposed](https://offthepace.mintlify.app/findings/sao-paulo-2021.md): Decomposing the Hamilton vs Verstappen final stint at the 2021 Brazilian Grand Prix to measure strategy advantage and driver skill in seconds.
- [Contributing to Off The Pace](https://offthepace.mintlify.app/platform/contributing.md): From zero to running models in under 30 minutes. Prerequisites, setup, pipeline commands, and the PR process.
- [Repository conventions](https://offthepace.mintlify.app/platform/conventions.md): How this repository is laid out, documented, and kept readable by humans and coding agents alike.
- [Architecture Decision Log](https://offthepace.mintlify.app/platform/architecture-decisions.md): The ten key decisions that shape Off The Pace's stack DuckDB, CDN parquet, ONNX browser runtime, and more. Each entry captures the decision, rationale, and tradeoff.
- [Deployment & release runbook](https://offthepace.mintlify.app/platform/deployment.md): How Off The Pace ships keyless Workload Identity Federation, staged promotion from staging to prod, preview deploys for every PR, and rollback.
- [Data pipeline & quality](https://offthepace.mintlify.app/platform/data-pipeline.md): The scheduled, retried, quality-gated DAG that rebuilds the warehouse ingest through publish and verify with three data-quality layers and automatic manifest rollback on mismatch.
- [Observability & SLOs](https://offthepace.mintlify.app/platform/observability.md): In-browser error tracking and RUM via an env-gated Sentry facade, plus black-box synthetic monitoring of the CDN serving plane the direct guard against stale-manifest incidents.
- [Performance, E2E & coverage](https://offthepace.mintlify.app/platform/performance.md): End-to-end browser tests of the wasm subsystems, a hard JS bundle-size budget, advisory Lighthouse CI, and coverage-threshold ratchets across JS and Python suites.
- [Security policy](https://offthepace.mintlify.app/platform/security.md): Vulnerability reporting, automated supply-chain and SAST controls, and the GitHub settings required to harden the build and deploy pipeline.
- [Data layer overview: sources, Bronze, and how data flows](https://offthepace.mintlify.app/data/overview.md): Where Off The Pace's F1 data comes from, what the Bronze layer stores, and how it flows into the transform layer the orientation page for the Data tab.
- [Architecture: how ingestion works](https://offthepace.mintlify.app/ingestion/architecture.md): The full control flow of ingest.py every per-dataset writer, the retry envelope, the data-quality gate, and the manifest it all reports through readable without opening the source.
- [FastF1: the primary timing source](https://offthepace.mintlify.app/data/source-fastf1.md): What FastF1 provides, its quirks schema drift, on-disk caching, mixed time formats and the retry envelope that absorbs transient blips.
- [Jolpica: reference data for standings and pit stops](https://offthepace.mintlify.app/data/source-jolpica.md): Why Off The Pace uses Jolpica, the Ergast-compatible successor, for driver/constructor standings and classified pit stops and why it's reference data, not timing data.
- [Raw data schemas: laps, weather, telemetry, race control](https://offthepace.mintlify.app/reference/data-schemas.md): The four Bronze-layer Parquet schemas from FastF1 and OpenF1 that feed the decomposition pipeline: laps, weather, telemetry, and race control events.
- [Laps](https://offthepace.mintlify.app/reference/schemas/laps.md): Bronze-layer fact table.
- [Race Control](https://offthepace.mintlify.app/reference/schemas/race_control.md): Bronze-layer event log.
- [Telemetry](https://offthepace.mintlify.app/reference/schemas/telemetry.md): Bronze-layer event log.
- [Weather](https://offthepace.mintlify.app/reference/schemas/weather.md): Bronze-layer dimension.
- [Data quality: checks, severity tiers, and expected gaps](https://offthepace.mintlify.app/data/data-quality.md): The four checks ingestion runs on every Bronze write, the one condition that actually blocks a write, and which gaps are expected rather than corruption.
- [Known issues and expected gaps](https://offthepace.mintlify.app/data/known-issues.md): The data quirks Bronze doesn't smooth over FastF1 regressions, sparse telemetry, undecoded enums, and the phantom columns that don't actually exist.
- [Quickstart: ingest your first race](https://offthepace.mintlify.app/ingestion/quickstart.md): Zero to a verified race on disk in five minutes: install, ingest one session, verify, and explore it lap by lap.
- [Choosing how much data to pull](https://offthepace.mintlify.app/ingestion/data-scope.md): Five ingestion scopes, from zero-network test fixtures to a full multi-hour backfill pick the smallest one that fits what you're building.
- [ingest.py: the full CLI surface](https://offthepace.mintlify.app/ingestion/cli.md): Every ingest.py flag what it does, its default, and the validation rules that govern how they combine.
- [Configuration: environment variables and the FastF1 cache](https://offthepace.mintlify.app/ingestion/configuration.md): The full ingestion config surface three optional environment variables, no credentials, and how the on-disk FastF1 cache works.
- [Monitoring a long-running backfill](https://offthepace.mintlify.app/ingestion/monitoring.md): Run ingestion in the background and let a stdlib-only watcher catch failures early, instead of staring at a multi-hour terminal session.
- [Verify: confirm Bronze integrity](https://offthepace.mintlify.app/ingestion/verify.md): Re-run the data-quality gate against every file already on disk, and regenerate the coverage table the rest of the docs link to.
- [Manifest report: every ingestion run, queryable](https://offthepace.mintlify.app/ingestion/manifest-report.md): Turn the per-run manifest Parquet files into a status summary what's ok, skipped, or errored, and whether FastF1's schema drifted between runs.
- [Replay: step through a race lap by lap](https://offthepace.mintlify.app/ingestion/replay.md): Walk one race's Bronze laps in order, printing each driver's lap as it would have happened useful for spot-checking ingestion or debugging a specific lap.
- [Transform layer overview: the model DAG and the eight families](https://offthepace.mintlify.app/transform/overview.md): How dbt and DuckDB turn Bronze Parquet into feature marts the materialization strategy, the tuning knobs, and a map of the eight model families that make up the transform layer.
- [The seven-term lap decomposition identity explained](https://offthepace.mintlify.app/decomposition/seven-term-identity.md): Understand the additive identity that breaks every lap into six physics terms plus a driver residual enforced as a CI contract to within 0.1 ms.
- [How lap time components are identified and estimated](https://offthepace.mintlify.app/decomposition/methodology.md): Learn how sequential residualisation separates six simultaneous physics signals from driver skill and why the estimation order matters.
- [Understanding and predicting tyre cliff onset with ML](https://offthepace.mintlify.app/decomposition/tyre-cliff.md): Learn how Kaplan-Meier survival analysis detects tyre cliff onset and how ML models extend the population prior to per-lap, per-stint predictions.
- [Known limitations of the lap decomposition pipeline](https://offthepace.mintlify.app/decomposition/limitations.md): Understand where the decomposition model is reliable, where estimates carry more uncertainty, and what data the FIA and FastF1 do not expose.
- [Staging family: Bronze Parquet to typed views](https://offthepace.mintlify.app/transform/families/staging.md): The layer's only contact with Bronze Parquet: rename to snake_case, cast nanoseconds to seconds, derive a handful of validity flags. No business logic.
- [Reference family: seed-backed and laps-derived dimensions](https://offthepace.mintlify.app/transform/families/reference.md): Four dimension tables: two lift fitted coefficients from committed seeds, two derive identity facts live from stg_laps on every build.
- [Physics family: deterministic and EMA lap state](https://offthepace.mintlify.app/transform/families/physics.md): Eight models computing per-lap physics state fuel mass, push load, dirty air, corner g all partitioned on the stint identifier every later window function reuses.
- [Pace Baselines family: the curves every lap is measured against](https://offthepace.mintlify.app/transform/families/pace-baselines.md): Six models building the field, rubber/ambient, compound, and constructor pace curves the only family where every model is also exported straight to the app, alongside its DAG role.
- [Skill family: de-biasing the car to leave the driver](https://offthepace.mintlify.app/transform/families/skill.md): Seven models, two parallel systems: a four-stage car-FE to LORO to shrink to era-bridge rating pipeline exported straight to the app, plus one independent pairwise signal that is the family's only ML feature.
- [Residual Decomposition family: the seven-term identity and what it leaves over](https://offthepace.mintlify.app/transform/families/residual.md): Nine models built around one closure equation: the lap-grain 7-term identity, its sector and corner-grain refinements, its qualifying mirror, and three diagnostics fit on top of the closed residual.
- [Strategy family: pit-stop and safety-car decision support](https://offthepace.mintlify.app/transform/families/strategy.md): Counterfactual, base-rate and stint-ending models built on top of the closed residual and the cliff prediction one already shipped to the app, others built ahead of any consumer.
- [Feature Marts family: the gold layer](https://offthepace.mintlify.app/transform/families/marts.md): Ten models that turn six families of intermediate work into the contract with ml/ and app/ two column-exact ML feature tables, a wide analytics table, and seven specialty marts built for one consumer each.
- [stg_circuit_info](https://offthepace.mintlify.app/reference/models/stg/stg_circuit_info.md): Corner geometry from FastF1 circuit_info.corners.
- [stg_events](https://offthepace.mintlify.app/reference/models/stg/stg_events.md): Race-level events (damage, retirements, penalties) sourced from the raw_dim_events seed.
- [stg_laps](https://offthepace.mintlify.app/reference/models/stg/stg_laps.md): Cleaned lap-level data from FastF1 race sessions.
- [stg_laps_qualifying](https://offthepace.mintlify.app/reference/models/stg/stg_laps_qualifying.md): Cleaned qualifying lap data (Q1/Q2/Q3), mirroring stg_laps for qualifying sessions.
- [stg_pits](https://offthepace.mintlify.app/reference/models/stg/stg_pits.md): One row per pit stop: a lap carrying PitInTime.
- [stg_results](https://offthepace.mintlify.app/reference/models/stg/stg_results.md): Official classified race results from FastF1 session.results.
- [stg_sector_times](https://offthepace.mintlify.app/reference/models/stg/stg_sector_times.md): Per-sector timing unpivoted from stg_laps.
- [stg_session_status](https://offthepace.mintlify.app/reference/models/stg/stg_session_status.md): Session lifecycle events from FastF1 session.session_status (Inactive / Started / Aborted / Finished / Finalised).
- [stg_telemetry](https://offthepace.mintlify.app/reference/models/stg/stg_telemetry.md): High-frequency car telemetry (~10 Hz) from FastF1, one row per sample.
- [stg_track_status](https://offthepace.mintlify.app/reference/models/stg/stg_track_status.md): SC/VSC/yellow/red timeline from FastF1 session.track_status.
- [stg_tyre_allocations](https://offthepace.mintlify.app/reference/models/stg/stg_tyre_allocations.md): Pirelli weekend compound nominations for 2019-2024: which C-code each of hard/medium/soft actually was, per race.
- [stg_weather](https://offthepace.mintlify.app/reference/models/stg/stg_weather.md): Weather snapshot nearest each lap start.
- [int_circuit_x_constructor_interaction](https://offthepace.mintlify.app/reference/models/int/int_circuit_x_constructor_interaction.md): One row per (race_year, race_id, constructor_id).
- [int_compound_cliff_predicted](https://offthepace.mintlify.app/reference/models/int/int_compound_cliff_predicted.md): Tyre compound degradation prediction using fitted survival-analysis parameters.
- [int_constructor_car_fe](https://offthepace.mintlify.app/reference/models/int/int_constructor_car_fe.md): De-biased constructor car pace (constructor×race fixed effect), one row per (race_year, race_id, constructor_id).
- [int_constructor_deg_sensitivity](https://offthepace.mintlify.app/reference/models/int/int_constructor_deg_sensitivity.md): One row per (race_year, constructor_id, compound).
- [int_constructor_structural_pace](https://offthepace.mintlify.app/reference/models/int/int_constructor_structural_pace.md): One row per (race_year, race_id, constructor_id).
- [int_constructor_structural_pace_qualifying](https://offthepace.mintlify.app/reference/models/int/int_constructor_structural_pace_qualifying.md): One row per (race_year, race_id, constructor_id).
- [int_corner_metrics](https://offthepace.mintlify.app/reference/models/int/int_corner_metrics.md): Per-corner telemetry metrics.
- [int_corner_skill_residuals](https://offthepace.mintlify.app/reference/models/int/int_corner_skill_residuals.md): One row per lap per named corner.
- [int_dirty_air_tax_component](https://offthepace.mintlify.app/reference/models/int/int_dirty_air_tax_component.md): One row per lap.
- [int_driver_circuit_affinity](https://offthepace.mintlify.app/reference/models/int/int_driver_circuit_affinity.md): One row per (driver_id, circuit_id).
- [int_driver_circuit_era_affinity](https://offthepace.mintlify.app/reference/models/int/int_driver_circuit_era_affinity.md): One row per (driver_id, circuit_id, era_key).
- [int_driver_race_skill_loro](https://offthepace.mintlify.app/reference/models/int/int_driver_race_skill_loro.md): De-confounded absolute equal-car skill, race grain (race_year, race_id, driver_id).
- [int_driver_season_ratings](https://offthepace.mintlify.app/reference/models/int/int_driver_season_ratings.md): One row per (driver_id, season).
- [int_era_normalized_driver_rating](https://offthepace.mintlify.app/reference/models/int/int_era_normalized_driver_rating.md): One row per (driver_id, season).
- [int_event_corrections](https://offthepace.mintlify.app/reference/models/int/int_event_corrections.md): Safety car, red flag, and other race event corrections.
- [int_field_pace_curve](https://offthepace.mintlify.app/reference/models/int/int_field_pace_curve.md): Field-level baseline pace curve.
- [int_lap_air_state](https://offthepace.mintlify.app/reference/models/int/int_lap_air_state.md): Air state classification and thermal load from dirty air.
- [int_lap_anomaly_flags](https://offthepace.mintlify.app/reference/models/int/int_lap_anomaly_flags.md): Anomaly detection flags for data quality control.
- [int_lap_fuel_state](https://offthepace.mintlify.app/reference/models/int/int_lap_fuel_state.md): Fuel burnoff and weight correction.
- [int_lap_fuel_state_qualifying](https://offthepace.mintlify.app/reference/models/int/int_lap_fuel_state_qualifying.md): One row per qualifying lap.
- [int_lap_residual_decomposed](https://offthepace.mintlify.app/reference/models/int/int_lap_residual_decomposed.md): One row per lap.
- [int_lap_residual_decomposed_qualifying](https://offthepace.mintlify.app/reference/models/int/int_lap_residual_decomposed_qualifying.md): One row per qualifying lap.
- [int_lap_residual_stint_detrend](https://offthepace.mintlify.app/reference/models/int/int_lap_residual_stint_detrend.md): Per-stint linear drift of driver_skill_residual_s against lap_in_stint, fit on pre-cliff laps only (cliff_onset_passed = FALSE) via OLS REGR_SLOPE.
- [int_lap_telemetry_aggregates](https://offthepace.mintlify.app/reference/models/int/int_lap_telemetry_aggregates.md): Per-lap telemetry features for the tyre-cliff model.
- [int_lap_thermal_proxy](https://offthepace.mintlify.app/reference/models/int/int_lap_thermal_proxy.md): Cumulative push load from tyre thermal management.
- [int_pit_loss_circuit](https://offthepace.mintlify.app/reference/models/int/int_pit_loss_circuit.md): Empirical circuit-specific pit-lane loss prior, read by int_pit_strategy_value in place of the largely-imputed circuit_reference constant.
- [int_pit_strategy_cost_curve](https://offthepace.mintlify.app/reference/models/int/int_pit_strategy_cost_curve.md): One row per (stint_id, horizon_scope, candidate_pit_lap_offset): the Total_Cost(L) surface int_pit_strategy_value's header described for two years and never computed.
- [int_pit_strategy_value](https://offthepace.mintlify.app/reference/models/int/int_pit_strategy_value.md): One row per stint.
- [int_qualifying_decomposed](https://offthepace.mintlify.app/reference/models/int/int_qualifying_decomposed.md): One row per qualifying lap.
- [int_sc_hazard_history](https://offthepace.mintlify.app/reference/models/int/int_sc_hazard_history.md): Safety-Car / Virtual-Safety-Car base rate per circuit (venue slug) as a hazard per racing lap, POINT-IN-TIME AS OF THE START OF EACH SEASON.
- [int_sector_residual_decomposed](https://offthepace.mintlify.app/reference/models/int/int_sector_residual_decomposed.md): One row per lap per sector (3 rows/lap).
- [int_stint_geometry](https://offthepace.mintlify.app/reference/models/int/int_stint_geometry.md): Foundation for all downstream window functions.
- [int_synthetic_teammate](https://offthepace.mintlify.app/reference/models/int/int_synthetic_teammate.md): Synthetic teammate for driver skill extraction.
- [int_track_evolution](https://offthepace.mintlify.app/reference/models/int/int_track_evolution.md): Track temperature and grip evolution over race.
- [int_tyre_surface_vs_bulk_decoupling](https://offthepace.mintlify.app/reference/models/int/int_tyre_surface_vs_bulk_decoupling.md): One row per lap (post-cliff only).
- [fct_cliff_prediction_features](https://offthepace.mintlify.app/reference/models/fct/fct_cliff_prediction_features.md): Lap-grain feature table for the tyre cliff XGBoost model.
- [fct_driver_skill_features](https://offthepace.mintlify.app/reference/models/fct/fct_driver_skill_features.md): Race-grain driver skill feature table for the driver skill extraction model.
- [fct_ghost_car_pace](https://offthepace.mintlify.app/reference/models/fct/fct_ghost_car_pace.md): One row per (ego_driver, host_constructor, race, lap).
- [fct_ghost_race_finish](https://offthepace.mintlify.app/reference/models/fct/fct_ghost_race_finish.md): One row per (host_constructor, ego_driver, race).
- [fct_lap_residuals](https://offthepace.mintlify.app/reference/models/fct/fct_lap_residuals.md): Lap-grain analytics table.
- [fct_stint_features](https://offthepace.mintlify.app/reference/models/fct/fct_stint_features.md): One row per stint.
- [fct_telemetry_deltas](https://offthepace.mintlify.app/reference/models/fct/fct_telemetry_deltas.md): Driver-vs-teammate corner-metric deltas.
- [mart_corner_skill_driver](https://offthepace.mintlify.app/reference/models/fct/mart_corner_skill_driver.md): Driver corner skill vs a LORO (leave-one-race-out) same-car baseline.
- [mart_degradation_history_envelope](https://offthepace.mintlify.app/reference/models/fct/mart_degradation_history_envelope.md): Pre-aggregated historical stint envelope for the Degradation Simulator.
- [dim_circuits](https://offthepace.mintlify.app/reference/models/dim/dim_circuits.md): One row per event slug (circuit_key).
- [dim_compounds_season](https://offthepace.mintlify.app/reference/models/dim/dim_compounds_season.md): One row per circuit × compound × season.
- [dim_constructors](https://offthepace.mintlify.app/reference/models/dim/dim_constructors.md): One row per constructor (team).
- [dim_drivers](https://offthepace.mintlify.app/reference/models/dim/dim_drivers.md): One row per driver_id.
- [dim_events](https://offthepace.mintlify.app/reference/models/dim/dim_events.md): Race-level event dimension.
- [The CI Contract: how the transform layer's test suite keeps the DAG honest](https://offthepace.mintlify.app/transform/ci/overview.md): The test pyramid that guards every model in the transform layer generic column contracts clubbed by the pattern they share, and the hand-written assertions that prove the seven-term identity actually closes.
- [Structural tests: grain and completeness across every model](https://offthepace.mintlify.app/transform/ci/structural.md): not_null, unique, and unique-combination tests are the largest test family by count and the simplest by idea every model's declared key is present once and only once.
- [Range & domain tests: plausibility, enums, and monotonicity](https://offthepace.mintlify.app/transform/ci/range-and-domain.md): The three value-shape generic test families, clubbed together because they share one theme: every number and label in the warehouse stays inside the range that's physically or logically possible.
- [Identity-closure tests: the additive identities, enforced](https://offthepace.mintlify.app/transform/ci/identity-closure.md): The fourteen hand-written assertions that prove the transform layer's additive identities and shrinkage bounds hold exactly, not approximately, on every row of every build.
- [Domain-constraint tests: physical and statistical invariants](https://offthepace.mintlify.app/transform/ci/domain-constraints.md): Thirteen singular tests that aren't additive closures stint resets, look-ahead guards, honest ranges, and probability sanity checks on the models that feed Physics, Skill, and Strategy.
- [Regression gates: baseline comparison, lint, and byte-stability](https://offthepace.mintlify.app/transform/ci/regression-gates.md): The gates that don't return data-quality violations on a single build two baseline-comparison tests, the sqlfluff hard-fail lint gate, and the byte-stability oracle that proves a style fix never moved model output.
- [Macros: the seven reusable building blocks](https://offthepace.mintlify.app/transform/macros.md): The seven dbt macros that keep shrinkage, filtering, mapping, validation, and numeric logic defined once instead of copy-pasted across models grouped by what they do, each linking to its full signature and usage.
- [assert_additive_identity](https://offthepace.mintlify.app/reference/macros/assert_additive_identity.md): Validates that an additive identity holds: total = sum(components) + residual ± tolerance
- [bayesian_shrinkage](https://offthepace.mintlify.app/reference/macros/bayesian_shrinkage.md): Computes Bayesian shrinkage estimate from observed data and prior.
- [circuit_id_from_name](https://offthepace.mintlify.app/reference/macros/circuit_id_from_name.md): Derive a stable physical-circuit identifier from a circuit's display name.
- [clean_lap_filter](https://offthepace.mintlify.app/reference/macros/clean_lap_filter.md): Reusable WHERE clause predicate for filtering to 'clean' laps suitable for driver skill extraction.
- [normal_cdf](https://offthepace.mintlify.app/reference/macros/normal_cdf.md): Standard normal CDF Phi(x).
- [normalize_compound](https://offthepace.mintlify.app/reference/macros/normalize_compound.md): Maps Pirelli's 2018-era legacy compound names onto the modern SOFT/MEDIUM/HARD taxonomy so that compound-parameter joins (dim_compounds_season) land for 2018.
- [posterior_variance](https://offthepace.mintlify.app/reference/macros/posterior_variance.md): Computes posterior variance from normal-normal conjugate model.
- [Machine learning for tyre prediction in Off The Pace](https://offthepace.mintlify.app/ml/overview.md): Five XGBoost models extend the physics decomposition to predict next-lap pace loss, cliff proximity, and remaining stint life across seven seasons of F1 (2018–2024).
- [Feature contract: the 33 features and the read-only mart](https://offthepace.mintlify.app/ml/feature-contract.md): 33 features across 6 physics groups, all read from fct_cliff_prediction_features. The machine layer never re-derives physics it reads the decomposition's output and writes nothing back.
- [The ML pipeline: eight stages from features to reference docs](https://offthepace.mintlify.app/ml/pipeline.md): make ml-all runs the full ML pipeline in eight deterministic stages features → tune → train → evaluate → predict → onnx → card → reference. Each stage reads a defined set of inputs, writes a defined set of outputs, and makes a specific guarantee.
- [Features and targets: how a mart row becomes a training row](https://offthepace.mintlify.app/ml/features-and-targets.md): How fct_cliff_prediction_features is loaded, encoded, fingerprinted, and audited and the three targets the models predict.
- [Five XGBoost tyre prediction models and their metrics](https://offthepace.mintlify.app/ml/models.md): Degradation quantile trio, cliff classifier, and stint-life regressor five XGBoost models, every one beating a per-cohort baseline, with full metrics.
- [Hyperparameter tuning: Optuna search, CV selection, and full refit](https://offthepace.mintlify.app/ml/tuning.md): How Optuna TPESampler explores the 9-dimensional hyperparameter space for each of the five models, selects on season-grouped CV, and then refits on the full training set.
- [ONNX export: parity gate and in-browser scoring](https://offthepace.mintlify.app/ml/onnx.md): Every XGBoost booster is exported to ONNX and must pass an exact round-trip parity test (atol=1e-5, including NaN-bearing rows) before anything ships to the browser.
- [Model validation: leakage spine, CV, and the adversarial probe](https://offthepace.mintlify.app/ml/validation.md): Season-grouped TimeSeriesSplit, a five-guard leakage spine, adversarial probes, and the MAX+1-derived holdout policy that flips to a true reveal when 2025 ingests.
- [Calibration: does the 80% interval actually cover 80%?](https://offthepace.mintlify.app/ml/calibration.md): The degradation quantile trio claims an 80% prediction interval. Here is the maths that proves it coverage indicator, the split-conformal conformity score, the CQR quantile, and the finite-sample guarantee.
- [Cohorts surfaced, never dropped](https://offthepace.mintlify.app/ml/cohorts.md): Every model is evaluated across compound, circuit, and rain-lap cohorts. Underperforming cells are recorded in the model card and published here never hidden.
- [The CI contract: 40 tests across six groups](https://offthepace.mintlify.app/ml/ci/overview.md): 40 tests 14 leakage-spine guards, 5 ONNX parity, 3 predict-schema, 7 evaluation gates, 1 target bound, 10 version-contract checks. Run them all with make ml-test.
- [The leakage spine: 28 guards, one idea each](https://offthepace.mintlify.app/ml/ci/leakage-spine.md): The 28 tests in test_features.py that make temporal leakage structurally impossible from column exclusions to the sqlglot forward-window and aggregation-scope audits to the MAX+1-derived holdout.
- [Parity and schema: ONNX, predict output, and target bounds](https://offthepace.mintlify.app/ml/ci/parity-and-schema.md): 5 ONNX parity tests, 3 predict-schema tests, and 1 target synthesis test the mechanical contracts that ensure the browser sees what training produced and the output schema never silently changes.
- [Evaluation gates: beats-baseline, calibration, and cohorts](https://offthepace.mintlify.app/ml/ci/evaluation-gates.md): The 7 tests in test_evaluate.py that assert every model beats its per-cohort baseline, calibration coverage is computed, cohorts are surfaced not dropped, and metrics match the model card.
- [Off the Pace-Tyre Degradation Predictors (v12)](https://offthepace.mintlify.app/reference/ml/degradation-model.md): Five XGBoost models predicting cumulative 5-lap tyre-degradation pace loss (quantile trio p10/p50/p90), laps-until-cliff class, and remaining stint life, from per-lap thermal, dirty-air, powertrain, weather and compound-prior features.
- [Off The Pace app: browser-native F1 analytics](https://offthepace.mintlify.app/app/overview.md): A zero-server React app powered by DuckDB-Wasm and ONNX. Parquet files load in your browser; every SQL query runs locally in under 10 ms.
- [How the app runs entirely in your browser](https://offthepace.mintlify.app/app/architecture.md): A zero-server, three-layer stack: GCS-hosted Parquet files, DuckDB-Wasm for SQL, and ONNX Runtime Web for ML inference all executing inside your browser tab with no backend at request time.
- [Ghost Car: driver skill in equal machinery](https://offthepace.mintlify.app/app/families/ghost-car.md): Three features that transplant drivers into a common car and re-run the race, turning subjective impressions of 'strong drives' into quantified, car-removed rankings and championship simulations.
- [A driver's track record in equal machinery](https://offthepace.mintlify.app/app/ghost-race-standings.md): A per-circuit, per-era leaderboard ranking drivers by car-removed pace, so the board reads as driver skill at that track rather than whose car was quickest.
- [How would the championship look in one chosen car?](https://offthepace.mintlify.app/app/counterfactual-championship.md): Every driver transplanted one at a time into a chosen host car and re-scored against the real grid, summed into a what-if championship across a season.
- [Which drives were better than the result showed?](https://offthepace.mintlify.app/app/hidden-performance.md): Drivers whose ghost-projected finish beat their actual result strong drives masked by car pace, strategy, or circumstance.
- [Lap Decomposition: the seven-term identity at every scale](https://offthepace.mintlify.app/app/families/lap-decomposition.md): Three features that apply the seven-term lap decomposition fuel, compound, rubber, ambient, constructor, dirty air, driver skill at per-lap, full-race, and per-sector resolution.
- [Lap waterfall: visualize the seven-term decomposition](https://offthepace.mintlify.app/app/lap-waterfall.md): A waterfall chart showing how fuel, compound, rubber, ambient, constructor, dirty air, and driver skill each contribute to a driver's pace delta, with track noise shown as a diagnostic.
- [Where did a driver's race actually go?](https://offthepace.mintlify.app/app/race-lost.md): The per-lap decomposition summed across an entire race, turning average-per-lap components into total seconds gained or lost to each cause.
- [Which part of the lap is the driver finding time in?](https://offthepace.mintlify.app/app/sector-decomposition.md): The lap decomposition applied to each of the three timing sectors separately, allocating physics components by sector time share so sectors sum to the lap.
- [Tyre & Strategy: from observed degradation to optimal stops](https://offthepace.mintlify.app/app/families/tyre-strategy.md): Five features spanning tyre survival curves, stint degradation timelines, pit-strategy Gantts, post-cliff recovery forecasts, and the qualifying-vs-race pace gap the full arc from data to decision.
- [How long does a tyre survive before the cliff?](https://offthepace.mintlify.app/app/tyre-cliff-survival.md): A Kaplan-Meier survival curve estimating the probability a stint reaches each lap without hitting the degradation cliff, validated against where real stints actually ended.
- [How much pace each compound loses over a stint](https://offthepace.mintlify.app/app/stint-degradation-timeline.md): The average pace a tyre compound loses relative to fresh rubber across a race, with a spread band showing how differently drivers managed the same tyre.
- [Was the pit stop on the optimal lap?](https://offthepace.mintlify.app/app/pit-strategy.md): A Gantt of every stint in a race, marking where each tyre hit the cliff, where the model says the optimal stop was, and how much time a late stop cost.
- [Can a tyre recover once it is past the cliff?](https://offthepace.mintlify.app/app/tyre-recovery-forecast.md): Post-cliff tyre behaviour by compound: how often a worn tyre shows pace recovery when the driver backs off, and whether the wear is thermal (recoverable) or structural (not).
- [Which teams find more in qualifying than in the race?](https://offthepace.mintlify.app/app/party-mode.md): The gap between each constructor's single-lap qualifying pace and their sustained race pace, separating qualifying specialists from race-spec cars.
- [Aero & Conditions: the environment every lap is driven into](https://offthepace.mintlify.app/app/families/aero-conditions.md): Four features covering the two environmental axes that sit outside any driver's control: aerodynamic disturbance from running in traffic, and the circuit's own evolution in grip and baseline pace across a race.
- [How many seconds did dirty air cost each driver?](https://offthepace.mintlify.app/app/dirty-air-cost.md): A leaderboard of the cumulative time each driver lost to running in disturbed airflow during a race, from the per-circuit dirty-air model.
- [What air was each driver running in, lap by lap?](https://offthepace.mintlify.app/app/dirty-air-lap-map.md): A lap-by-lap grid of the aerodynamic environment every driver experienced free air, dirty air, tow, or DRS train across a whole race.
- [How much did the track speed up during the race?](https://offthepace.mintlify.app/app/track-evolution.md): The lap-time baseline split into rubber buildup and ambient drift, showing how much the circuit itself changed underneath the field over a race.
- [What pace did the field actually run, lap by lap?](https://offthepace.mintlify.app/app/field-pace-curve.md): The trimmed field-average lap time across a race, blending fuel burn, tyre degradation, and track rubbering into one reference baseline.
- [Race Craft: the race as it actually unfolded](https://offthepace.mintlify.app/app/families/race-craft.md): The events that interrupt a race rather than the pace that decides it safety cars, virtual safety cars and red flags, on the lap each one happened.
- [When did the race stop being a race?](https://offthepace.mintlify.app/app/race-control.md): Every safety car, VSC and red flag in a race, on the lap it happened and for as long as it lasted plus an honest account of why there is no per-circuit safety-car probability anywhere on the page.
- [Drivers: isolating skill from the car, nine ways](https://offthepace.mintlify.app/app/families/drivers.md): Nine features that each strip a different confound out of raw lap times to leave a signal that reflects the driver rather than the machinery career ratings, circuit and weather affinity, workload, and head-to-head duels.
- [Tracking driver pace across eras on one scale](https://offthepace.mintlify.app/app/era-ratings-timeline.md): Each driver's era-adjusted pace rating across seasons, corrected for the 2022 regulation change and shown with honest confidence ribbons.
- [Visualizing driver consistency across races and seasons](https://offthepace.mintlify.app/app/driver-consistency.md): Plot each driver's residual skill mean and variance after removing all six physics factors see who delivers reliably and who runs hot and cold.
- [Qualifying specialist or race-day driver?](https://offthepace.mintlify.app/app/quali-vs-race-skill.md): Each driver's skill residual in qualifying plotted against their skill in the race, separating one-lap merchants from drivers who come alive over a stint.
- [Which circuits suit each driver's style?](https://offthepace.mintlify.app/app/driver-circuit-affinity.md): A heatmap of how much faster or slower each driver is at a specific circuit, relative to their own season average, after removing car and field effects.
- [Comparing drivers across regulation eras](https://offthepace.mintlify.app/app/era-translator.md): A season leaderboard of era-adjusted driver ratings on one comparable scale, anchored by drivers who raced on both sides of the 2022 regulation change.
- [Who is genuinely faster in the wet?](https://offthepace.mintlify.app/app/wet-race-specialist.md): Each driver's wet-weather skill advantage their race skill residual in the wet minus their dry baseline across their full 2018–2024 career.
- [Who works their tyres and runs in traffic the most?](https://offthepace.mintlify.app/app/driver-workload.md): Four tyre and traffic stress signals aggregated per driver per season push, stint age, dirty-air share, and cliff risk revealing who races hardest on their rubber.
- [Same car, same race who would be faster?](https://offthepace.mintlify.app/app/synthetic-teammate.md): A pace comparison that weight-corrects each driver against a synthetic teammate, isolating pure skill from strategy and track-position effects.
- [Isolating corner technique from car performance](https://offthepace.mintlify.app/app/corner-phase-skill.md): A driver skill index built from braking, mid-corner, and exit deviations relative to each driver's own car baseline so a fast car can't flatter a driver.
- [Constructors: isolating car pace from the driver](https://offthepace.mintlify.app/app/families/constructors.md): Two features that read the constructor's contribution to lap time from a fixed-effects panel model the season-level structural pace and the per-circuit interaction term after controlling for driver skill, tyre state, and conditions.
- [How fast is each car, with the driver removed?](https://offthepace.mintlify.app/app/constructor-structural-pace.md): Each constructor's car contribution to lap time from a fixed-effects panel model, after controlling for driver skill, tyre state, fuel, and conditions.
- [Which circuits suit each car?](https://offthepace.mintlify.app/app/constructor-circuit-interaction.md): A heatmap of how each constructor over- or under-performs at specific circuits relative to their own season average the circuit × constructor interaction term.
- [The Machine: ML transparency and live inference](https://offthepace.mintlify.app/app/families/the-machine.md): Three features that expose the tyre-degradation ML models a live ONNX-scored simulator, a held-out blind-test scoreboard, and a full evaluation dashboard so the model's behaviour is auditable, not a black box.
- [Simulate tyre wear curves with the degradation model](https://offthepace.mintlify.app/app/degradation-simulator.md): Dial compound, fuel, and conditions to watch XGBoost models predict pace loss, cliff risk, and tyre life scored live in your browser via ONNX.
- [How are the degradation models scored?](https://offthepace.mintlify.app/app/model-metrics.md): The evaluation dashboard for the tyre-degradation models temporal holdout, per-cohort baselines, conformal calibration, and SHAP-vs-permutation feature importance, all read from the model card.
- [How well do the degradation models hold up out of sample?](https://offthepace.mintlify.app/app/blind-test-scoreboard.md): The degradation models scored on a held-out season predicted-vs-actual scatter, interval coverage, and a cliff-class confusion matrix, all read from the model card.
- [Data & Validation: verify the numbers yourself](https://offthepace.mintlify.app/app/families/data-validation.md): Two transparency features a live SQL editor backed by DuckDB-Wasm and a per-race pipeline quality audit so you can interrogate the data directly rather than taking the charts on faith.
- [Run SQL against the gold marts in your browser](https://offthepace.mintlify.app/app/query-lab.md): A full SQL editor backed by DuckDB-Wasm. Write raw queries against every registered gold mart no credentials, no server, results in milliseconds.
- [How many laps actually survive the pipeline's quality gate?](https://offthepace.mintlify.app/app/data-quality-audit.md): Per-race usable-lap counts and a breakdown of every excluded lap type neutralisation, rain, out/in laps, and anomalies for a season.

## Optional

- [Launch App](https://off-the-pace.web.app)
- [Docs](https://offthepace.mintlify.app/)
- [GitHub Repository](https://github.com/JustinClarke/off-the-pace)