Daniel Litvak
All projects

Future Projects

Planned builds, organized by priority.

Each project was chosen to fill a specific gap in the current skillset relative to target co-op roles. Every entry includes the real-world motivation, the skills it develops, and a concrete implementation plan.

IoT Environmental Monitor + Real-Time Dashboard

A Raspberry Pi or Arduino sensor node that streams air quality data through MQTT to a Python backend, stores time-series records in PostgreSQL, and pushes live updates to a Next.js dashboard via WebSockets.

C / MicroPython
MQTT
Python
PostgreSQL
WebSockets
Next.js
Docker

Why it matters

Deployed sensor data becomes a genuinely useful public health tool during wildfire season. The same architecture underpins industrial IoT monitoring, environmental compliance systems, and smart building dashboards.

Skills this builds

  • WebSockets / real-time state
  • IoT / sensor-to-cloud pipeline
  • MQTT protocol
  • Time-series data modeling
  • Hardware-software bridge project
  • Docker containerization
  • Linux server administration

Implementation plan

  1. 1Wire a DHT22 temperature/humidity sensor and MQ-135 CO₂ sensor to a Raspberry Pi or Arduino Nano 33 IoT.
  2. 2Write embedded firmware (C or MicroPython) that reads sensors on a 30-second interval and publishes JSON payloads to an MQTT broker topic.
  3. 3Stand up a local Mosquitto MQTT broker, then write a Python subscriber that parses incoming payloads and inserts them into a PostgreSQL table (timestamp, sensor_id, metric, value).
  4. 4Build a Next.js API route that serves the last N readings and a WebSocket endpoint that pushes new readings to connected clients in real time.
  5. 5Build the frontend dashboard: a live line chart (Recharts), current readings summary card, and a historical range selector.
  6. 6Containerize the Python subscriber and PostgreSQL with Docker Compose so the entire backend starts with one command.
  7. 7Deploy to Railway or Fly.io free tier and document the full architecture in the README with a wiring diagram.

RISC-V Pipeline Simulator with Visual Debugger

An interactive browser tool that accepts RV32I assembly, steps instructions through a 5-stage pipeline, and visualizes hazard detection, stalls, and forwarding paths cycle by cycle.

TypeScript
React
RISC-V
WebAssembly (stretch)

Why it matters

An open-source, deployable computer architecture teaching tool that any CPEN 211-equivalent course could link students to. Extremely rare at the co-op level and an immediate differentiator for Intel and AMD applications.

Skills this builds

  • CPU microarchitecture depth (pipelines, hazards, forwarding)
  • TypeScript at scale with complex state modeling
  • Open-source project structure and documentation
  • WASM performance optimization (stretch goal)
  • State machine design in software

Implementation plan

  1. 1Define the instruction subset: RV32I base (ADD, SUB, AND, OR, LW, SW, BEQ, JAL) — enough to demonstrate all hazard types.
  2. 2Write a TypeScript lexer and parser for RV32I assembly that produces a typed instruction list with decoded operand fields.
  3. 3Build the pipeline state machine: each stage holds the current instruction and its fields; each clock tick advances instructions and checks for RAW hazards.
  4. 4Implement stall insertion and forwarding path selection as explicit state transitions with labeled reasons.
  5. 5Build the React UI: register file display, pipeline stage diagram, memory view, cycle counter, and step/run/reset controls.
  6. 6Add an annotation layer that renders stall bubbles, forwarding arrows, and hazard labels directly on the pipeline diagram.
  7. 7Write a test suite covering at least 20 assembly programs including back-to-back loads, dependent arithmetic chains, and branch-not-taken sequences.
  8. 8Deploy to GitHub Pages and write a thorough README explaining the architecture — this is the open-source signal.

Docker + Cloud Deployment of Existing Project

Containerize the Simple Nodal Analysis Tool with Docker, add an nginx reverse proxy, write a CI/CD pipeline that builds and pushes an image on merge, and deploy to a cloud provider with a public live URL.

Docker
Docker Compose
nginx
GitHub Actions
Railway / Fly.io
Linux
Python / Flask

Why it matters

Every running deployed service is stronger evidence than a local-only project. Closes the single most broadly shared gap across target job postings in one weekend.

Skills this builds

  • Docker image authoring and multi-stage builds
  • Docker Compose multi-service orchestration
  • nginx reverse proxy configuration
  • CI/CD pipeline: build → lint → push image
  • Cloud deployment (Railway or Fly.io)
  • Environment variable and secret management in production
  • Linux server basics

Implementation plan

  1. 1Write a Dockerfile for the Flask app: Python slim base, copy requirements.txt, pip install, COPY source, EXPOSE 5000, CMD gunicorn app:app.
  2. 2Write a docker-compose.yml that runs the Flask container behind nginx on port 80 with a volume for static assets.
  3. 3Test locally: docker compose up, hit the /solve endpoint, confirm responses match the local Flask output exactly.
  4. 4Write a GitHub Actions workflow: on push to main, build the image, tag it with the commit SHA and latest, and push to GitHub Container Registry (GHCR).
  5. 5Deploy to Railway or Fly.io using the GHCR image. Inject environment variables through the platform dashboard, not the image.
  6. 6Add a /health endpoint to the Flask app that returns 200 OK and configure the cloud platform to monitor it.
  7. 7Update the Simple Nodal Analysis Tool portfolio entry to link to the live deployed URL.

UBC Course & Degree Planner

A tool that parses the UBC course calendar into a prerequisite graph, lets students mark completed courses to see what unlocks, and visualizes full prerequisite chains interactively with a D3 force graph.

Python
BeautifulSoup
PostgreSQL
Next.js
React
D3.js
REST API

Why it matters

Thousands of UBC Engineering students struggle with degree planning using the slow official tools. A fast, visual prerequisite explorer with a degree audit is immediately useful — and deployable to the same Vercel account as the portfolio.

Skills this builds

  • Python web scraping and data pipeline
  • Graph data modeling applied to real data
  • D3.js force-directed graph visualization
  • REST API design with PostgreSQL
  • Real user research and product iteration

Implementation plan

  1. 1Write a Python scraper (requests + BeautifulSoup) that parses the UBC course calendar and extracts course code, title, credits, prerequisites, and corequisites for all Engineering and CS courses.
  2. 2Normalize the prerequisite strings into a structured graph: nodes are courses, directed edges are prerequisite relationships with OR/AND logic as edge metadata.
  3. 3Load the graph into PostgreSQL: a courses table and a prerequisites table with source, target, and logic_type columns.
  4. 4Build a Next.js API: GET /courses, GET /courses/:code, GET /courses/:code/prerequisites (recursive depth), and POST /audit (given completed codes, return available courses).
  5. 5Build the React frontend: a searchable course list, a D3 force-directed graph for the prerequisite chain of a selected course, and a degree audit panel.
  6. 6Add a semester planner view where students drag courses into future term slots and see which prerequisites are satisfied.
  7. 7Deploy to Vercel (frontend) and Railway (backend + PostgreSQL) with a shareable public URL.

Python Data Pipeline on BC Hydrometric Data

A reproducible Python pipeline that ingests real-time ECCC hydrometric station data for BC rivers, computes rolling statistics and anomaly flags, and produces a visual report with confidence intervals and a station map.

Python
pandas
NumPy
scikit-learn
Matplotlib / Plotly
Jupyter
folium
REST API

Why it matters

Water level monitoring supports flood early warning, drought management, and interjurisdictional water agreements. Demonstrating the ability to work with ECCC operational data is a direct signal for the Water Resources Data Analyst role.

Skills this builds

  • Python data pipeline: requests → pandas → analysis → export
  • Time-series statistical analysis
  • Confidence intervals and uncertainty visualization
  • scikit-learn anomaly detection (IsolationForest or z-score)
  • Reproducible Jupyter notebooks
  • GIS basics: station coordinates on a folium map
  • Public REST API data ingestion

Implementation plan

  1. 1Explore the ECCC National Hydrological Service Datamart API and identify 5–10 representative BC stations (Fraser River, Capilano, Campbell River).
  2. 2Write a Python ingestion script that pulls hourly water level and discharge readings for a rolling 90-day window and stores them in a local SQLite or CSV database.
  3. 3Use pandas to clean the data: handle missing readings, normalize units, and align timestamps across stations.
  4. 4Compute rolling statistics: 7-day moving average, rolling standard deviation, and a z-score anomaly flag for readings more than 2σ from the local rolling mean.
  5. 5Add STATS 302-style confidence intervals around the rolling mean and visualize them with Matplotlib or Plotly shaded bands.
  6. 6Build a Jupyter notebook that tells the full story: data source, cleaning decisions, statistical methodology, and interpretation of anomalous readings.
  7. 7Add a folium station map that plots current water levels color-coded by anomaly status (green / yellow / red).
  8. 8Export the analysis as a clean PDF report and a structured CSV for reproducibility — these map to the ECCC job's 'prepare presentations' and 'write technical documents' responsibilities.

Real-Time Collaborative Study Whiteboard

A WebSocket-based collaborative whiteboard for tutoring sessions with shared canvas drawing, real-time cursor presence, LaTeX equation rendering, and optional Claude API integration for in-session explanations.

Node.js
Socket.io
React
Canvas API
KaTeX
PostgreSQL
Claude API (optional)

Why it matters

Immediately deployable for your own tutoring students. A focused no-account whiteboard for remote tutoring is genuinely better than Zoom's built-in tools and something tutors at UBC would actually use.

Skills this builds

  • WebSockets / Socket.io real-time state synchronization
  • Room-based multi-user session management
  • Canvas API drawing and event replay
  • Node.js server architecture and broadcasting
  • Claude API / AI feature integration (optional)

Implementation plan

  1. 1Set up a Node.js + Socket.io server with room-based connection management: each session gets a unique ID that students join via a shareable URL, no account required.
  2. 2Implement canvas sync: on every pointer event, emit a draw operation to the room. The server broadcasts it to all other clients immediately.
  3. 3Build the React canvas component that handles local drawing and applies incoming remote draw operations without flickering.
  4. 4Add cursor presence: broadcast cursor positions and render small labeled cursors for each remote participant on the canvas.
  5. 5Add a toolbar: pen, eraser, color picker, stroke width, clear, and single-step undo.
  6. 6Add LaTeX equation rendering: a text tool that accepts LaTeX, renders it via KaTeX, and stamps it as a repositionable canvas element.
  7. 7Add session persistence: save canvas state snapshots to PostgreSQL every 30 seconds so sessions can be reviewed after they end.
  8. 8(Optional) Add a Claude API sidebar: send the current canvas as a screenshot plus a student question to the Claude API and display the explanation inline.
  9. 9Deploy to Fly.io (Node.js + Socket.io backend) and Vercel (React frontend).