Skip to content
М

Boston, MA

AI & software engineer

Matt Serdukoff

I build production AI systems that hold up under real use: retrieval pipelines, LLM features with guardrails, and the full-stack products around them.

AI Engineer / Full-Stack Developer at Hime, building Wheelbase. Creator of Grammario and Lociros, NLP products for language learners. Contributor to pandas.

“I refuse to ship something that .”

Featured work

View all projects
01
ActiveDealership operations platform

Wheelbase

Auction intelligence, inventory, and recon for used-car dealers. Hybrid vector search ranks every auction car against real inventory gaps; a governed AI assistant runs the rest.

  • 80%+

    less DB load after the Go rewrite

  • 66

    tables under Row Level Security

  • 3

    surfaces: web, desktop, mobile

wheelbase.ioLive
Wheelbase homepage: The hardest worker in the car business
TechTypeScript / React / TanStack Start / tRPC / Go / Electron / Expo / Supabase / PostgreSQL / Docker
02
ActiveGraded readers, checked

Lociros

Graded readers where A2 is actually A2. Every passage is checked by a morphological analyzer before you read it.

Languages · A1–B2

Japanese / Arabic / Italian / Russian

lociros.comLive
Lociros homepage: Every word has depth, beside an engraved cliff of Japanese words graded A1 to B2
03
ActiveGrammar you can see

Grammario

Click a sentence. See the structure. Universal Dependencies first, AI explanation second.

Languages

Italian / German / Russian / Turkish / Spanish / Japanese

grammario.aiLive
Grammario homepage: See the grammar you missed, beside an Italian example analysis that catches a gender agreement mistake

More projects

GitHub ↗
  • 04

    Purser

    Automated GitHub changelogs

    A read-only GitHub App that turns each merged pull request into a reviewed changelog draft: dependency bumps and CI-only diffs are filtered out before any model call, then one Claude call writes a customer-facing note, a technical note, a category, and a confidence score. Approved entries push to Slack and an in-app launcher widget, with Stripe plans and Upstash QStash jobs so it runs serverless on Vercel.

    • Never stores diffs; installation tokens minted per request
    • Breaking changes always wait for a human
    • One job path: QStash in production, after() locally

    Next.js / Supabase / GitHub Apps / Upstash QStash

  • 05

    Global Terrorism Visualization

    3D globe and dashboard

    Interactive WebGL globe over 177,000+ records from the Global Terrorism Database (1970–2017), plus a seven-view analytics dashboard covering trends, regions, attack types, targets, weapons, and hotspots.

    • Pandas cleaning pipeline: coordinates, NaN imputation, type coercion
    • 8-endpoint FastAPI with analytical aggregations
    • Sampled to 5,000 points to keep the globe smooth

    React / Globe.gl / FastAPI / Pandas

  • 06

    Teen Phone Addiction Prediction

    Behavioral ML pipeline

    Random forest regressor predicting adolescent phone-addiction risk from behavioral survey data, tracked with MLflow and served through a FastAPI endpoint that always loads the latest registered model, with a Streamlit dashboard for exploration and live prediction.

    • Every run logs params, seven metrics, and the model artifact
    • API auto-serves the newest registered model
    • Streamlit EDA and feature-importance playground

    Python / scikit-learn / MLflow / FastAPI

  • 07

    SkinGuard

    Lesion classification

    Binary skin-lesion classifier (benign vs. malignant) trained on 10,015 HAM10000 dermatoscopic images, with four training pipelines across TensorFlow and PyTorch and export to Apple Core ML for on-device iOS/macOS inference.

    • Custom CNNs, class-balanced 224×224 pipeline
    • MLflow tracking of per-epoch loss and accuracy
    • Core ML .mlpackage export via coremltools

    TensorFlow / PyTorch / coremltools / MLflow

  • Linux process monitor

    A minimal, htop-inspired process monitor in C++17 with an ncurses UI, reading live process data straight from the Linux /proc filesystem and refreshing every second.

    • Process / System / UI layers composed by dependency injection
    • POSIX directory traversal to enumerate PIDs
    • cmdline → comm → [unknown] fallback for kernel threads

    C++17 / ncurses / POSIX / procfs

  • Core stack

    Python / Go / TypeScript / SQL / C++ / React / Next.js / FastAPI / Gin / PyTorch / scikit-learn / spaCy / pgvector / PostgreSQL / Docker / AWS

    Full skills breakdown →

Impact

Measured, not claimed.

A few of the numbers behind the work, from production systems and the codebases they run on.

  • 80%+

    less database load

    Re-engineered Wheelbase's backend from Python/FastAPI to Go/Gin with zero breaking changes. Responses went sub-second.

  • ~217

    tRPC procedures

    Across 35 domain routers, over a 66-table Postgres schema with Row Level Security on every table.

  • 0

    external API calls per VIN decode

    Replaced a paid VIN API with an offline Go service over a ~2GB NHTSA database, with check-digit validation and auto-correction.

  • 60%

    faster translation turnaround

    AWS Bedrock document pipelines for Massachusetts A&F, processing 200+ financial documents a month with layout-preserving PDF reconstruction.

  • 9s → 4s

    Grammario analysis latency

    Parse, LLM explanation, and embedding run concurrently with asyncio.gather. The dependency tree itself renders in 300–500ms.

  • Merged

    into pandas core

    PR #64567 replaced a misleading plotting error with an accurate diagnostic, merged by a core maintainer without revisions.

Experience

  1. Jan 2024–Present

    Remote

    AI Engineer / Full-Stack Developer

    Hime · Wheelbase ↗

    Own full-stack delivery of Wheelbase, a multi-tenant dealership operations platform, across a React/TypeScript front end, Go and Python APIs, and Supabase Postgres, shipped to web, Electron desktop, and an Expo mobile field app from one Turborepo monorepo.

    • Built production AI features: a natural-language-to-SQL operations assistant with risk-tiered write approval, vector-powered demand matching, and operational recommendations.
    • Built hybrid inventory search fusing 768-dim pgvector embeddings with Postgres full-text ranking via Reciprocal Rank Fusion, powering the IMX auction scoring system.
    • Re-engineered backend services from Python/FastAPI to Go/Gin, cutting database load by 80%+ and bringing latency under a second with zero breaking changes.
    • Designed tenant-scoped schemas and Row Level Security across 66 tables so isolation is enforced by Postgres, not application code.
    • Replaced a paid VIN-decoding API with an offline Go service over a ~2GB NHTSA SQLite database: multi-pass pattern matching, check-digit validation, auto-correction.
    • Built streaming CSV ETL for auction runlists with per-auction column mapping and 500-row batch writes, and set up GitHub Actions CI/CD with Docker and Nginx.
    • Onboarded and mentored a new engineer through the monorepo, and turned requirements from finance and operations stakeholders into shipped features.

    Go / TypeScript / React 19 / tRPC / Supabase / pgvector / Electron / Expo / Docker

    Engineering case study →
  2. Mar–Sep 2025

    Boston, MA

    AI Engineering & Data Science Intern

    Massachusetts Executive Office for Administration and Finance

    Built AI-assisted document workflows for state government, where output had to be accurate, traceable, and usable by non-technical staff.

    • Automated multilingual translation of 200+ financial documents a month with AWS Bedrock and AWS Translate.
    • Cut translation turnaround by 60% while preserving layout, deconstructing and rebuilding PDF structure with borb and PyMuPDF.
    • Worked directly with cross-functional government stakeholders to deliver production-grade workflows with high accuracy requirements.

    Python / AWS Bedrock / AWS Translate / PyMuPDF / borb

Education

  1. 2026–2028 (expected)

    M.S. Applied Data Analytics

    Boston University

    Part-time. Statistics, data analytics, and machine learning.

  2. 2019–2024

    B.S. Computer Science, Data Science concentration

    University of Massachusetts Lowell

    Operating Systems, Databases, Computer Architecture, Artificial Intelligence, Natural Language Processing, Analysis of Algorithms, Data Structures.

Skills

What I use, and where I've used it.

Grouped by the problems they solve, with the project that proves each one.

  • PythonPrimary
  • GoProduction
  • SQLExpert
  • TypeScriptProficient
  • C / C++Intermediate
  • BashProficient
  • RFamiliar
  • 01

    AI & LLM systems

    Production RAG ranking at Wheelbase, eight structured-output LLM services in Grammario, governed natural-language SQL, AWS Bedrock pipelines in government.

    • RAG
    • Hybrid retrieval (RRF)
    • Embedding pipelines
    • Prompt engineering
    • Structured JSON outputs
    • OpenRouter
    • OpenAI
    • Anthropic Claude
    • AWS Bedrock
  • 02

    NLP

    Dependency parsing and morphology across six languages, CEFR scoring from engineered features, analyzer-validated LLM generation.

    • spaCy
    • Stanza
    • sentence-transformers
    • Sudachi
    • pymorphy3
    • CAMeL Tools
    • NLTK
    • Universal Dependencies
  • 03

    Machine learning & data

    MLflow-tracked models served behind FastAPI, CNNs exported to Core ML, pipelines over 177K+ records and streaming ETL.

    • PyTorch
    • TensorFlow
    • scikit-learn
    • MLflow
    • pandas
    • NumPy
    • Core ML
    • ETL / streaming ingestion
  • 04

    Backend & databases

    A Go service that cut DB load 80%+, a 66-table RLS schema, pgvector with HNSW and IVFFlat indexes, Redis caching layers.

    • Go / Gin
    • Python / FastAPI
    • PostgreSQL
    • Supabase
    • pgvector
    • Redis
    • SQLite
    • tRPC
    • REST
  • 05

    Frontend & apps

    A 68-route React 19 app, an Electron desktop shell running tRPC over IPC, an Expo field app with a custom native VIN scanner.

    • TypeScript
    • React
    • Next.js
    • TanStack
    • Tailwind CSS
    • Electron
    • Expo / React Native
    • Yjs
    • ReactFlow
  • 06

    Infrastructure

    Per-service Docker images behind Nginx, path-filtered GitHub Actions deploys, serverless background jobs on Vercel.

    • Docker
    • Nginx
    • GitHub Actions
    • AWS
    • Vercel
    • DigitalOcean
    • Dokploy
    • MinIO
    • Stripe

Open source

PR #64567 ↗

pandas-dev/pandas · Merged Mar 22, 2026

A clearer error in pandas.

Plotting a frame with duplicate column names told you there was no numeric data, even when every column was numeric. The real cause was in MPLPlot.__init__: with non-unique labels, data[col] returns a DataFrame instead of a Series, is_numeric_dtype says False, and every column is silently filtered out.

Real duplicate-column support would mean reworking label-based indexing across the plotting pipeline, which the issue itself flagged as a much larger job. So I scoped it: a guard clause before any filtering, and a parametrized regression test for both plot kinds. It merged as submitted.

Closes
#64546
Diff
+11 / −0
Merged by
jbrockmendel, core maintainer
Before · every column is numeric
df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
df.columns = ["a", "a"]

df.plot.hist()
# TypeError: no numeric data to plot
Fix · pandas/plotting/_matplotlib/core.py
if isinstance(data, ABCDataFrame):
    if self._kind in ("hist", "box") and not data.columns.is_unique:
        raise ValueError("plotting requires unique column names")

→ ValueError: plotting requires unique column names

About

Structure first, model second.

I'm an AI and software engineer in Boston, MA. At Hime I build Wheelbase end to end, from Postgres security policies to the retrieval layer to the React app dealers use every day. On my own I built Grammario and Lociros, NLP products for language learners, and at the Massachusetts Executive Office for Administration and Finance I built AWS Bedrock pipelines that translate financial documents without breaking their layout.

I build the whole path a feature travels: the schema and its security policies, the retrieval and ranking layer, the model call and its guardrails, the API, and the interface someone actually touches. Then I measure it. The Go rewrite of Wheelbase's backend cut database load by more than 80%; parallelizing Grammario's analysis pipeline took a nine-second wait down to four.

My rule for AI work is structure first, model second. Grammario only lets the LLM explain grammar after a deterministic parser has already found it. Lociros never trusts a model's claim that a passage is A2; a morphological analyzer checks every word. Wheelbase's assistant can write SQL, but only inside a hardened Postgres function it cannot escape, and destructive writes wait for an approval token. Language models are powerful and unreliable, so I put them where their fluency helps and put hard checks where their mistakes would cost something.

I learn fast by building. Wheelbase ingestion got too slow in Python, so I learned Go and rewrote it . I picked up a pandas plotting bug and got the fix merged upstream. Outside of code I read history and science, and I am always partway through learning another language.

Languages I've studied.

The languages are not a side note. I speak Russian, study Italian, Turkish, German, Hebrew, and Japanese, and that is where the NLP work comes from. Knowing firsthand that Turkish stacks suffixes while Italian inflects is why Grammario runs a different analysis strategy per language family instead of one generic pipeline. It is also why I built Grammario and Lociros: one to see the structure of a sentence instead of memorizing rules, the other for reading practice that actually matches my level.

  • English

    Native

  • Russian

    Native

  • Italian

    Proficient

  • Turkish

    Proficient

  • German

    Basic

  • Hebrew

    Basic

  • Japanese

    Basic

Contact

Hiring for AI or backend work?

Open to roles in AI engineering, ML, data, and software engineering, Boston metro or US-remote. US citizen, no sponsorship needed. Reach out if you're hiring, or just want to talk shop.