Matthew Wind
Matthew Wind

Matthew Wind

SWE

I love building things

Experience

Jan 2026 – Aug 2026

Chief Technology Officer

Pipeline
  • Architected an async AI intake pipeline (Python, FastAPI, Gemini 2.5 Flash, MongoDB, Redis) that turns customer photos and text into structured diagnoses, constrained to a curated trade taxonomy. A single cached inference feeds both close-out survey generation and auto-scheduling, with seed fallbacks so a model failure never blocks a job.
  • Built a from-scratch constraint-based scheduling solver (no OR-tools) that decomposes each technician's day into free intervals and fits jobs against customer time windows, travel time, and dual work-hour caps, using soft reservations to prevent double-booking; a shared slot-fit core makes the per-job proposer and org-wide batch scheduler produce identical assignments, and a parallel diagnostic re-runs the same predicates to explain why no slot fit.
  • Instrumented an AI-evaluation flywheel that logs every technician visit as a labeled example — freezing each intake prediction against ground truth with per-field accuracy and a deferred 7-day fix confirmation — plus human scheduling overrides (accepted rank vs. the model's pick); a deterministic, explainable scorer persists all sub-scores so ranking weights re-tune offline without re-running inference.
PythonMongoDBFastAPIClaude CodeGoogle GeminiGoogle CloudCloudinaryReactRedisTypeScriptVercelRenderTwilio
Jun 2025 – Aug 2025

Software Engineering Intern

Capital One
  • Engineered the component and live-dependency testing layer for Testify, an internal VSCode extension available to Capital One's 10,000+ engineers, developing in TypeScript/JavaScript to validate the extension against real downstream services.
  • Delivered the first component-testing suite for an internal VSCode extension using ExTester and Jest, authoring 30+ test cases that mapped every interaction path to achieve 100% coverage while navigating the Kotlin backend to test end to end.
TypeScriptJavaScriptKotlinJiraJestAmazonwebservices
Jan 2025 – May 2025

Software Engineering Intern

Shopwave
  • Built client-facing reporting and analytics features across Shopwave's point-of-sale and inventory-management systems using React, Next.js, TypeScript, and MaterialUI, surfacing sales trends, inventory levels, and demand forecasting for merchants.
  • Developed "Where to Next," a conversational tool letting merchants evaluate expansion opportunities through a chat interface backed by Amazon Bedrock models (Claude, Titan) that queried internal and external APIs to ground responses in live market and business data; built in React/Next.js and deployed on Vercel.
ReactTypeScriptJavaScriptNextjsMaterialuiVercelAmazonwebservicesTailwind CSS
Aug 2024 – Dec 2025

CS 307 (Software Engineering) Teaching Assistant

Purdue University
  • Advised 10+ teams on system architecture — framework selection, data modeling, API design, and design-pattern choices — grounding each recommendation in the tradeoffs (coupling, scalability, maintainability) it optimized for.
  • Reviewed design docs and sprint deliverables for architectural integrity, flagging structural issues in schema design and module boundaries early and validating that implementation stayed faithful to the agreed design
May 2024 – Aug 2024

Software Engineering Intern

Federal Home Loan Bank of Chicago
  • Developed and enhanced complex FinTech applications with the bank’s modern engineering team, gaining experience with various tools and learning how to operate under an Agile software development cycle using the .NET framework.
  • Improved the bank’s DevSecOps processes using various cloud infrastructures, including Azure DevOps, to support continuous integration and development by building intuitive pipelines, increasing deployment speed by up to 20%.
.NETAzuredevopsAzureDocker

Projects

EdVenture

  • A full-stack social platform for study-abroad students (React 19 + TypeScript, Node/Express, MongoDB).
  • Architected real-time group messaging on a room-per-group Socket.IO layer bound to the Express HTTP server, persisting each message before broadcasting to the room so every client renders through a single event path, backed by a MongoDB/Mongoose data model on a React 19 + TypeScript stack.
  • Built stateless JWT authentication with httpOnly cross-site session cookies re-verified per request, bcrypt hashing, Google OAuth 2.0 login and account-linking, and a two-phase email-OTP flow, plus student verification and enumeration-safe password reset.
TypeScriptMongoDBGoogle CloudZodReactViteMUIJavaScriptNodejsVercelCloudinaryRender

Figgie Genius

  • A browser extension and analytics service that plays Jane Street's "Figgie" trading game.
  • Built a Chrome extension (Manifest V3) that reconstructs live Figgie game state from the rendered DOM via an event-driven TypeScript scraper (MutationObservers over the trade feed and eight per-suit bid/offer boards), resilient to UI changes through icon/color/path anchoring rather than positional selectors.
  • Designed a Python/FastAPI analytics service (Pandas/NumPy/SciPy) to maintain running Bayesian estimates of each suit's probability of being the common/goal suit and per-card fair value from the live order-book stream, flagging bids/offers that diverge from fair value as arbitrage signals.
PythonPostgreSQLFastAPISQLAlchemyDockerReactViteMUI

Explorio

  • A travel-itinerary generator that merges many vendor APIs into one day plan.
  • Designed a polymorphic Event type hierarchy that unified four incompatible third-party APIs — Amadeus (flights), Booking.com (hotels), Skyscanner (car rentals), and Google Places (dining/activities) — behind a single dispatch-on-read model, letting the itinerary renderer merge heterogeneous vendor payloads into one chronologically sorted day plan and handle them uniformly.
  • Built the itinerary-generation engine as a fan-out → normalize → schedule pipeline: issued category-specific Places queries, unioned the results into one candidate pool, normalized weekday conventions across APIs, and constraint-filtered venues by per-weekday opening hours to slot meals and activities into fixed daily time windows.
DartFirebaseGoogle Cloud

Analyst Trading Strategy (Boiler Quant Finance Group)

  • A Python/Jupyter quant strategy that builds two technical indicators from scratch, fuses their signals, and backtests the result.
  • Implemented the Parabolic SAR indicator from scratch as a stateful, streaming O(n) state machine — seeding trend over the first three bars, advancing SAR = prevSAR + AF·(EP − prevSAR), ratcheting the acceleration factor toward each new extreme point, and flipping trend (with an AF reset) on an SAR crossover — paired with a hand-written 14-period RSI computed from rolling average gains and losses.
  • Built a signal-fusion layer that confirms a Parabolic-SAR trend change only when a same-direction RSI threshold crossing (30 oversold / 70 overbought) falls within a ±5-bar window, consuming each RSI signal once so it can't corroborate twice, then ran the fused signals through an all-in/all-out portfolio backtester and scored them by Sharpe ratio and by Information ratio against a date-aligned S&P 500 benchmark.
  • Fronted the pipeline with a data-cleaning stage (yfinance OHLCV ingestion, 10-period rolling-mean imputation, duplicate removal, and SciPy z-score outlier rejection) and an orchestration harness that runs the full clean → indicators → fuse → backtest → metrics flow per ticker across a basket of equities, with Matplotlib price/PSAR/RSI/returns overlays.
PythonpandasNumPySciPyMatplotlib

Kalshi Alt-Data Predictions (Boiler Quant Finance Group)

  • Full-stack app that forecasts Kalshi's weekly "Top US Netflix Show" contract from alternative data, with a Python/FastAPI backend and a Next.js/TypeScript dashboard.
  • Built six modular data-source integrations behind a per-source service/router layout — Google Trends (pytrends), YouTube Data API with per-video sentiment scoring, Google News, Wikipedia pageviews, TMDB, and the Kalshi trade API — each exposed as typed REST endpoints.
  • Implemented authenticated Kalshi market access from scratch: RSA-PSS request signing over the timestamp/method/path triple, live event-market fetching for the Netflix ticker, and timestamped snapshot persistence.
  • Wrote the aggregation layer that turns six independent feeds into one comparable signal — fans out across all sources, normalizes show titles against Kalshi market strings (season suffixes, punctuation), degrades to per-source default models when an API fails or rate-limits, and writes versioned analysis snapshots.
  • Built the dashboard end to end: seven per-source cards plus a rollup summary view, a typed API client layer, and deployment config (CORS, Procfile, requirements).
PythonFastAPIPydanticpandasNextjsReactTailwind CSSMUITypeScriptRenderVercel

Coursework

Process Management & System Calls

  • Extended the XINU kernel with new process-creation system calls that reshape the run-time stack on creation so a "normally" terminating process returns into a custom kernel routine via a forged return address (INITRET-style macro), rather than falling off the end of its entry function.
  • Added system calls that derive a child's scheduling priority from its parent (inherit-plus-one or explicit, with range validation) and that introspect a parent process's state through the prparent process-table field, guarding every path against invalid PIDs.
C++C

Multi-Level Feedback Queue Scheduler

  • Implemented a multi-level feedback queue scheduler with a 9-entry policy table that decays priority on CPU-bound behavior, boosts on I/O completion, and scales timeslice inversely with priority (90 − 10i ms), validating it against starvation with an adversarial benchmark that games the quantum by yielding just before expiry.
  • Instrumented the clock-interrupt handler to track per-process CPU usage and ready-queue response time at millisecond granularity, classifying each process as CPU- or I/O-bound by whether it depleted its quantum or blocked voluntarily, and evaluating fairness across homogeneous, mixed, and staggered-arrival workloads.
C++C

Producer–Consumer Synchronization & Deadlock Detection

  • Implemented producer/consumer coordination over a shared circular buffer using counting semaphores for mutual exclusion and full/empty signaling among concurrent producers and consumers.
  • Extended XINU's semaphore system calls to maintain a process↔semaphore resource-allocation graph in statically allocated memory, running cycle detection twice per second from the clock handler to detect and print any deadlock cycle.
C++C

Kernel Garbage Collection

  • Added kernel-level garbage collection to XINU: wrapper allocation syscalls record every dynamically allocated block per process in an address-sorted linked list, so all memory a process leaks is automatically reclaimed to the free list on termination — with ownership checks that reject any attempt to free a region overlapping another process's allocation.
C++C

Unix-Style Inode File System

  • Reworked XINU's flat, linked index-block file system into a Unix-style inode using 15 direct data-block pointers plus singly, doubly, and triply indirect blocks, computing per-tier file-size thresholds to route getc/putc/seek/read/write through the correct level of indirection for large files.
C++C

Dynamic Memory Allocator (malloc)

  • A malloc/free/realloc implementation inspired by DLMalloc/PTMalloc.
  • Built a memory management library using segregated free lists indexed by size class with O(1) bidirectional coalescing via boundary tags, cutting per-block metadata by 16 bytes by packing allocation state into the low 3 bits of the size field and unioning free-list pointers with the user data region.
  • Managed OS heap memory as sbrk-requested arena chunks bounded by fencepost sentinels, coalescing adjacent chunks in place, splitting oversized blocks on allocation, merging with free left/right neighbors on deallocation, and falling back to a first-fit scan only for the unbounded final free list.
C++C

Unix Shell

  • A from-scratch shell combining behavior from bash and csh.
  • Built a Unix shell in C++ with a Flex/Bison grammar supporting arbitrarily long pipelines, input/output/error redirection (>, <, 2>, >&, >>, >>&), and background execution, driving each stage through fork/execvp with dup2 and pipe wiring and waitpid sequencing.
  • Layered on signal handling (SIGINT trapping and SIGCHLD-driven zombie reaping), ${…} environment and special-variable expansion, quoting/escaping, builtins (cd, setenv, source, exit), tilde and */? wildcard globbing via regcomp/regexec over readdir, $(…) subshells communicating over paired pipes, and a raw-mode line editor with command history and tab completion written without the readline library.
C++C

Shell-Scripting Toolkit

  • Three utilities: a password auditor, a CI test harness, and a process monitor.
  • Wrote a Bash password-strength scorer driven entirely by egrep regex classes — special characters, digit/alpha presence, repeated and consecutive character runs, and a common-password blacklist — with both file-based and argument-based input modes.
  • Built a Bash continuous-integration harness that clones a repo, builds it, and diffs each test's output against a reference binary under a timeout, publishing an auto-refreshing HTML report over a web server on a daily cron schedule; and a Python process monitor that reads PID/PPID/CPU/memory/thread stats directly from the /proc virtual filesystem.
C++C

Threads & Concurrency

  • POSIX threading, locking, and parallelism in C.
  • Worked through POSIX threads in C — spawning and joining pthreads, guarding a shared counter with mutexes and semaphores, and benchmarking a hand-rolled spin lock (with and without thr_yield) against the kernel mutex across user, system, and real time to expose the cost of busy-waiting.
  • Diagnosed and broke a circular-wait deadlock through lock ordering, implemented a bounded-buffer producer/consumer, demonstrated a stack buffer-overflow exploit that overwrites a local sentinel (to 0xdeadbeef) to redirect control into a hidden shell() function, and parallelized Conway's Game of Life with a geometric board decomposition and per-round barrier synchronization across worker threads.
C++C

Memory Dump & Pointer Library

  • Wrote a byte-level memory inspector in C that walks an arbitrary pointer and prints a 16-byte-per-row hex-and-ASCII dump (like xxd or gdb's x), plus a file-dump variant that fseek/ftell-sizes a file, malloc/freads it whole, and reuses the same routine — then used it to reverse-engineer the magic-number signatures of ELF, JPEG, GIF, WAV, TAR, and ZIP files.
  • Reimplemented the C string and array libraries (strlen, strcpy, strcat, strcmp, strstr, strdup, memcpy, plus min/max/find/sort) using pure pointer arithmetic with no array indexing, and empirically mapped the process address space (text/data/bss/stack/heap) and machine endianness by dereferencing tagged addresses.
C++C

x86-64 Assembly Programs

  • Hand-wrote AT&T-syntax x86-64 assembly programs — integer square/sum/average using idivq, an array-max scan, and a full in-place selection sort with an ascending/descending flag — managing the System V calling convention (%rdi/%rsi/%rdx/%rcx arguments, %rax returns), stack-frame setup and teardown, and scaled-index addressing for array access.
C++CAssemblyScript

Hash Table in x86-64 Assembly

  • Implemented a string-keyed hash-table dictionary — Java-style 31·h + c polynomial hash, prime-sized bucket array, separate-chaining lookup and update — entirely in x86-64 assembly, matching a reference C implementation across four benchmark suites.
  • Produced a hand-optimized second version guided by an instruction-level profiler — inlining the hash routine, reducing memory round-trips, and tightening the inner loop — to run the benchmark in under 75% of the baseline assembly's time.
C++CAssemblyScript

Simple-C Compiler

  • A one-pass compiler that translates a subset of C to x86-64 assembly.
  • Built a compiler for Simple-C (a subset of C with long/char*/long*/char**/void types and arrays, plus if/else, while, for, and do/while control flow) using Flex/Bison, emitting AT&T-syntax x86-64 assembly directly from embedded grammar actions as the parser walks the parse tree, and interoperating with the C runtime (printf, malloc).
  • Generated expression code with a register-stack virtual machine: evaluated expressions in Reverse-Polish order and mapped the bottom five expression-stack slots to registers (rbx, r10, r13, r14, r15), spilling to the execution stack only when deeper, while a layered precedence grammar (logical → equality → relational → additive → multiplicative → primary) enforced operator ordering.
  • Implemented global variables in the data segment (.comm) and local variables and arguments as frame-pointer (rbp) offsets tracked in per-scope symbol tables — reserving stack space via a back-patched constant written to an included file to work around the single pass — plus label-generated control flow (cmp/setcc/je/jmp) and a System V calling convention that pops arguments off the register stack into rdi/rsi/… with per-call argument counts to support nested calls.
C++C

bird.ai — Image-Detection SaaS

  • Built and repeatedly re-architected bird.ai, a Django image-detection SaaS (open-vocabulary YOLOE CNN inference), taking it from a single VM to a Kubernetes microservice deployment.
  • Deployed the Django application to AWS EC2 — configuring swap, SSH access, and security groups — then containerized it with Docker and made the deployment reboot-survivable using systemd service units and persistent volumes so the SQLite/Postgres state and web server recover automatically.
  • Evolved it into an N-tier architecture (nginx reverse proxy, Dockerized Django app, managed Postgres on RDS) with S3 + CloudFront media storage, content-hash image de-duplication, EXIF-GPS extraction for map plotting, and HTTPS with TLS terminated at the CDN edge — provisioning the whole stack as code with Terraform (S3-backed remote state, importing existing resources) and Ansible playbooks, and integrating boto3 for S3 uploads.
  • Migrated the monolith from EC2 + RDS onto Kubernetes (EKS): authored kustomize-managed Deployments, Services, ConfigMaps, Secrets, PersistentVolumeClaims, and an nginx Ingress; migrated the database via pg_dump into an in-cluster Postgres pod; and applied the Strangler-Fig pattern to extract YOLO inference (YOLOE-26L + MobileCLIP2) into an independently deployable Flask microservice that Django calls over an in-cluster Service.
AmazonwebservicesDjangoKubernetesDockerPostgreSQLTerraformAnsibleFlaskPython

Contact

LinkedIn
linkedin.com/in/matthewtwind/
GitHub
github.com/mtwind
Email
mtwind2003@gmail.com
Phone
+1 (630) 520-1540
Résumé
Download résumé (PDF)