DESIGN PHASE · BUILDING IN THE OPEN applied engineering case

F1 Data Platform: industrial-grade patterns, public data, built from scratch.

Six integrated cases around Formula 1 data — a Rust telemetry historian, layered ETL, a RAG agent with SQL tool-calling, comparative dashboards, strategy ML and a Flutter app. The same patterns DeepCode applies in regulated industrial environments (AVEVA PI System, GxP), rebuilt in the open to demonstrate applied knowledge end to end.

Follow on GitHub See the architecture

solution architecture

One platform, six cases

Every component consumes or feeds another. Historical data flows through a layered ETL into DuckDB; telemetry flows through a purpose-built historian into Parquet; services expose both to humans, dashboards and mobile.

1 — solution architecture. Cyan: historical/statistics flow. Purple: telemetry flow (dashed: PIMS query API consumed directly by mobile).

infrastructure

Where it runs

Deliberately lean: everything is reproducible from a laptop, CI runs on GitHub Actions, and each deployable finds its natural (free-tier-friendly) home. The AI agent's inference is pluggable — a headless Claude backend by default, swappable for an internal API.

2 — build, CI and runtime topology. Everything reproducible locally; deploys per component.

business processes

How the platform behaves (BPMN)

Three core processes modeled in BPMN notation: circles are events, rectangles are tasks, diamonds are decision gateways.

P1Historical data ingestion (scheduled)

P2Question answering (AI agent)

P3Telemetry ingestion with swinging-door compression (PIMS)

areas of the project

Six disciplines, one story

Each case is a self-contained repository with its own README, tests and CI — and a deliberate demonstration of one discipline.

Data Engineering 🎨 design

f1-data-platform · Python, DuckDB, Parquet

Layered ETL (raw → staging → marts) over the full history of Formula 1 (1950–today) via the Jolpica API. Idempotent, rate-limit-aware, with data-quality tests as first-class citizens: uniqueness, referential integrity, range checks.

ETLDuckDBData QualityIdempotency

Industrial Time-Series 🎨 design

f1-pims · Rust, Arrow/Parquet, axum

A minimal PIMS — the historian pattern used in industry (AVEVA PI) — built from scratch: tag/time-series data model, swinging-door compression with measured compression ratio, partitioned Parquet storage, and an HTTP query API with downsampling and interpolation.

RustHistorianSwinging DoorTime-Series

Dashboards 🎨 design

f1-telemetry-lab · Python, Streamlit, FastF1

PI-Vision-style comparative panels: driver vs driver speed/throttle/brake traces by distance, lap-by-lap gaps, tyre-stint degradation and position evolution — consuming the PIMS query API.

StreamlitTelemetryVisualization

Applied AI / RAG 🎨 design

f1-history-agent · Python, FastAPI

A headless agent that answers F1 history questions. Factual questions are resolved by SQL tool-calling (exact numbers, never hallucinated); narrative questions by RAG over a licensed corpus. Ships with a golden Q&A eval set and automated scoring. Inference is pluggable (headless Claude by default, internal API adapter).

RAGTool-callingEvalsFastAPI

Machine Learning 📋 phase 2

f1-strategy-ml · Python, scikit-learn

Tyre-degradation and pit-window models trained on the platform's own marts and telemetry — with honest validation and feature documentation.

RegressionFeature Eng.Validation

Mobile 📋 phase 2

f1-mobile · Flutter/Dart

Android/iOS client for the platform: chat with the history agent, browse seasons/drivers/results via the stats REST API, and view telemetry comparisons — offline-first with a local cache.

FlutterOffline-firstREST
glossary

Terms used in this project

PIMS / historian
Process Information Management System: industrial software that stores time-stamped sensor data (tags) efficiently and serves it for analysis — e.g. AVEVA PI System.
tag
A named time series in a historian (e.g. VER.speed): the unit of storage and query.
swinging-door compression
Classic historian algorithm that discards samples reconstructable by interpolation within a deviation band — massive storage savings with bounded error.
downsampling / interpolation
Serving a series at a coarser resolution (avg/min/max per window) or estimating values between stored points.
ETL (raw → staging → marts)
Layered pipeline: land data as-is, conform types and keys, then publish analytical tables ready for consumption.
DuckDB
In-process analytical SQL database — the platform's queryable store for historical marts.
Parquet
Columnar file format with compression; readable by DuckDB, pandas, Spark and Arrow ecosystems.
RAG
Retrieval-Augmented Generation: retrieving relevant documents (via embeddings) and grounding the LLM's answer in them.
tool-calling
Letting the LLM invoke typed functions (here: SQL queries) so factual answers come from the database, not from the model's memory.
embeddings / vector store
Numeric representations of text enabling semantic search; stored in a lightweight local index.
eval (golden set)
A fixed set of question/expected-answer pairs scored automatically — regression testing for AI behavior.
headless inference
Running the LLM behind an API/CLI with no UI; here pluggable between a local Claude backend and an internal API.
offline-first
Mobile pattern: the app works from a local cache and synchronizes when online.
BPMN
Business Process Model and Notation: standard diagrams for processes — events (circles), tasks (rectangles), gateways (diamonds).
follow along

Built in the open

The umbrella repository tracks the roadmap; each case graduates into its own repo with README, tests and CI as it ships.

github.com/rodrigolmanso/f1-portifolio