ALEX.RHODES
COMPUTER ENGINEERING, 3RD YEAR — STILL DECIDING WHICH HALF WINS

I build the boring infrastructure under interesting trades.

Most of what I've shipped isn't the model or the strategy — it's the unglamorous layer underneath: the scraper that doesn't fall over at 4am, the schema that doesn't need a rewrite every semester, the pipeline that just quietly runs. That habit comes from a computer engineering background (architecture, digital logic, C/C++) applied to a genuine interest in how markets actually get their data.

See what I've built Say hello

heads up — the panel on the right is a real screenshot-style mockup of my dev setup, not a live feed. didn't want to fake a "connected to the market" vibe I can't back up yet.

zsh — pipeline_dev — 96×28

$ python run_pipeline.py --env=dev

> connecting to source... ok

> transform layer loaded (pandas 2.2)

> last full run: 6h ago, 0 errors

# note to self: fix the timezone bug before demo day

DEV UPTIME, THIS SEM

99.9%

AVG LATENCY

~18ms

SCRIPTS SHIPPED

20+

COFFEE, THIS WEEK

n/a*

* tracker broke, ironically

> ▍

currently rebuilding the ETL retry logic for the third time / pipeline uptime this semester: 99.9% / automation scripts shipped: 20+ / favorite bug so far: the off-by-one in the backtester / languages I actually reach for: python, c/c++, vhdl / currently rebuilding the ETL retry logic for the third time / pipeline uptime this semester: 99.9% / automation scripts shipped: 20+ / favorite bug so far: the off-by-one in the backtester / languages I actually reach for: python, c/c++, vhdl /

Things I've built

not a curated highlight reel — the archived ones stay up because I'd rather show the dead ends too.

SHIPPED

Automated Stock Scraper & Analytics ETL Pipeline

Scrapes live and historical equity data, runs it through a Pandas transform layer, and lands it in a structured database. Built this after a class project where I hardcoded ticker symbols and swore I'd never do that again.

// architecture

source → selenium/requests → pandas transform → sql store → signal layer

Rewrote the retry logic twice — first version silently dropped failed requests instead of retrying them. Found out the hard way when a week of data just wasn't there.

PYTHON PANDAS SELENIUM SQL
ITERATING

Backtesting Framework

Vectorized engine for testing rule-based strategies against historical OHLC data. Currently arguing with myself over whether to add slippage modeling or keep it simple.

PYTHON NUMPY
SHIPPED

Custom Processor & ISA Simulator

Single-cycle processor in VHDL with a matching C++ instruction-set simulator, built for a computer architecture course and then kept expanding it after the semester ended because I got stubborn about the pipelining.

VHDL C++ FPGA
SHIPPED

Network Packet Analyzer

CLI tool for capturing and dissecting TCP/IP traffic. Built to actually understand what "the network layer" meant instead of just memorizing the OSI model for an exam.

C SOCKETS
ARCHIVED

CPU Scheduler Simulator

Round-robin and priority scheduling visualizer. Retired this one — the UI aged badly and I learned everything I needed from building it.

C++ OS THEORY

What I actually use

Grouped by the two halves of what I do — not a skills-bar chart, since "85% proficient in Python" never meant anything to me either.

Systems & Architecture

the coursework side, mostly

Computer Organization Digital Logic Assembly (x86/MIPS) VHDL / Verilog Network Protocols Operating Systems C / C++ FPGA Prototyping

Data & Automation

the self-taught side

Python Pandas / NumPy Selenium SQL / DBMS ETL Design REST APIs Git Cron / Task Scheduling

How I actually ended up here

I went into computer engineering for the hardware — computer organization and digital logic were the first classes that made the "how do computers actually work" question click. I didn't expect the markets interest to show up at all.

It started with a dumb project: scraping stock prices for a friend who wanted a spreadsheet that updated itself. The scraper broke constantly. Fixing it taught me more about building reliable systems than most of my coursework did — rate limits, retries, schema drift, all the unsexy stuff that doesn't show up in a tutorial.

Now most of what I build sits in that overlap: infrastructure that has to actually hold up, applied to data that people might use to make decisions with real money attached. I still don't know if I end up on the hardware side or the quant side long-term — probably why this site talks about both.