Mattia Chiesa

Lead Software Engineer (platform / systems)

Summary

-I build software where correctness, performance, and operational safety matter (data pipelines, numerical code, developer tooling).
-I often work at the platform layer: boundaries, contracts, migrations, and “how the system behaves under failure”.
-I keep systems maintainable with small APIs, explicit invariants, tests, and benchmarks.
-I work mostly in Rust and TypeScript; I do pragmatic AI integration when it helps (schema-driven data layers, retrieval/vector search).
-Current focus: deterministic market data pipelines and compute-only math modules in Rust.

-Designing and implementing a deterministic market data pipeline (ingest, backfill, gap detection/healing, derived timeframes).
-Defining boundaries across crates: domain invariants, compute-only math modules, persistence layer, long-running worker processes.
-Building restart-safe workflows (resume/retry policies, re-queueing, and bootstrap gating) to keep the pipeline predictable over time.
-Building a compute-only math kernel from scratch (state-space models, Markov/HMM primitives, signal processing, econometrics, and related building blocks), with explicit error contracts and deterministic behavior.
-Writing tests and benchmarks to keep time alignment, failure contracts, and performance budgets stable as the system grows.

-Owned shared project architecture for multi-tenant, content-heavy websites (structure, conventions, deployment patterns).
-Scope: platform transitions, internal frameworks/starters, and team supervision (including the Innsbruck office).
-Planned and coordinated a platform transition from a TYPO3 + Nuxt setup to a Next.js-based stack.
-Changed the CMS approach from “frontend + backend as separate projects” to a more unified delivery pipeline (clear boundaries, shared conventions, fewer handoffs).
-Built a middle-layer framework inside the Nuxt ecosystem to support TSX in Vue components (used across pages/sections; enabled reuse and more structured UI code).
-Built and maintained a reusable Next.js starter (typed config surface, SCSS structure, lint/type/style workflows).
-Focused on predictable builds, maintainable code structure, and workflows that make it easier for teams to ship consistently.
-Worked across a headless CMS stack (GraphQL/content APIs) and standardized patterns used across multiple sites.
-Delegated ownership of `davos.ch` to a junior developer and supervised delivery.

-Delivered web products end-to-end (frontend, backend, integrations) with an emphasis on maintainable foundations.
-Scope: workflow/tooling to make design-led Webflow projects maintainable and reproducible for developers.
-Built reusable tooling and patterns (project starters, shared utilities, build setup) instead of one-off implementations.
-Built and maintained a TypeScript/Webflow starter (Vite + TS + SCSS + lint/test tooling) to standardize projects and reduce setup friction.
-Built internal tooling to make Webflow projects more maintainable (local development workflow, Git-based iteration, and controlled sync back into the Webflow environment).

-Schema declared in Rust (`#[derive(OrsxMigrate)]`); migration planning diffs live tables (columns + indexes) and applies idempotent changes when possible.
-Online rewrite uses a shadow table + trigger-based changelog + chunked backfill, enforces a cutover lock budget, and retains the original table as a backup.
-Columnar retrieval via Postgres `COPY ... FORMAT BINARY` into typed buffers (`ColumnarBatch`), with `ColumnarReaderMode::Auto` to fall back to row-wise when it wins; perf and migration trials are recorded in the repo.
-Repo: https://github.com/tia-lab/orsx-2

-Implements local level (1D) and local linear trend (2D) Kalman filters for `f64` time series.
-Allocation-free `_into` APIs write into caller-provided output slices; validates finiteness and variance constraints and returns structured errors.
-Criterion benchmarks are checked in (example logs show ~10 ns/obs for local level and ~19 ns/obs for local trend on an Intel Xeon W-2295, release build).
-Repo: https://github.com/tia-lab/kalman

-Practical codec stack (delta + varint/zigzag + LZ4) with defensive decoding and property-based tests.
-Repo: https://github.com/tia-lab/cydec

-Procedural-macro ORM generating type-safe CRUD, filters, pagination, and batch operations from Rust structs.
-Designed to support multi-table / multi-timeframe schemas without duplicating models.
-Repo: https://github.com/tia-lab/orso

-Starter focused on typed content queries, a clear config surface, SCSS structure, and repeatable workflows.
-Repo: https://github.com/tia-lab/next-dato-starter

-Packages built around Zod schemas: SQL DDL/migrations, Turso/SQLite operations, and a Pinecone adapter.
-Repo: https://github.com/tia-lab/datazod

-University of Lausanne (UNIL) — Bachelor of Arts (BA), Computer Science & Mathematical Methods and Italian Literature, June 2014
-SUPSI — Master of Arts in Secondary Education, Mathematics, June 2017
-SUPSI — Certified coursework toward BSc in Computer Engineering (part-time alongside work): 39 ECTS (2012–2013); selected modules include analysis & linear algebra, numerical algorithms, discrete math & logic, and dynamical systems