Blake Rossi — Portfolio

2025–Present

OpenAILLM IntegrationPrompt EngineeringAI-Generated ProgramsSvelteKitTypeScriptC#/.NETEntity Framework CoreSQLiteTailwind CSS

Lionheart

AI Athletic Intelligence · OpenAI + SvelteKit + .NET

An AI-powered athletic intelligence platform built around an OpenAI chat agent that reasons over an athlete's full context — training logs, wearables, recovery, injuries, sleep, and subjective notes. Where traditional fitness apps surface single metrics, Lionheart unifies everything into one timeline and lets a language model generate the insights, programs, and feedback no single data point can reveal.

Unified data aggregation across training logs, wearables, injury notes, and journaling
AI / LLM integration for intelligent analysis over full athlete context
Backend APIs in C#/.NET with Entity Framework Core and SQLite
Clean SvelteKit + TypeScript frontend styled with Tailwind CSS & DaisyUI
Holistic athlete modelling with semantically meaningful data structures

GitHub

Training & Activity Logs

Every workout, rep, and recovery session is captured in a flexible logging system. Lionheart aggregates entries from manual input and connected wearables into a single timeline — giving athletes a clear, chronological view of their physical output without jumping between apps.

AI-Powered Insights

The chat interface connects directly to OpenAI's API, letting athletes ask natural questions about their training. The model considers full context — logs, injury notes, sleep, and mood — to surface insights that no single metric could reveal on its own.

Recovery & Injury Tracking

When injuries happen, Lionheart doesn't disappear. The injury module lets athletes log incidents, track recovery milestones, and contextualise how setbacks affect the broader training arc — keeping the long-term picture intact even during downtime.

Personal Experience

I joined a friend on the app after we'd brainstormed it for over a year. I learned everything my partner had already built and began work on the frontend, eventually touching every part of the project and implementing new ideas like an AI-generated training program. We worked with a professor from RIT whom we met with weekly; he mentored us on packaging Lionheart as an industry-ready product and pushed us to gather feedback throughout the process.

Spring 2026

Azure AI FoundryAzure AI LanguageAzure AI TranslatorPrompt EngineeringFastAPIPythonReactTypeScriptViteTerraformTMDB / OMDB

Movie Master

AI Movie Companion · Azure Foundry + FastAPI + React

An AI-first movie companion built around an Azure AI Foundry prompt agent, with TMDB / OMDB powering a fast browser layer underneath. Users chat with an AI movie expert, generate on-demand plot summaries through Azure AI Language, translate any reply through Azure Translator, and rate films to feed a recommendation loop — every AI service brokered through the FastAPI backend so credentials never touch the browser.

FastAPI backend orchestrating TMDB, OMDB, Azure AI Foundry, Azure Language, and Azure Translator
React + Vite frontend with a chat launcher, movie library, search, ratings, and recommendation views
Azure AI Foundry prompt-agent integration with graceful fallback when credentials are absent
Azure Language service for on-demand summaries of long-form movie metadata
Azure Translator pipeline for in-app translation across summaries and chat replies
Terraform-provisioned Azure stack — Foundry account, project, model deployment, Language, and Translator

The Movie Browser

The front door of the app. Users search TMDB / OMDB through a single unified query, browse rich detail pages, and save titles into a personal library. The React + Vite frontend keeps interactions snappy, while the FastAPI backend normalises responses from multiple movie providers into a single clean shape.

AI Chat Assistant

A floating chat launcher sits on every page, backed by Azure AI Foundry. The prompt agent is provisioned through a dedicated Python helper that reads instructions from disk and versions them in Foundry — so the assistant's behaviour is source-controlled. When credentials are absent, a clean fallback mode keeps the UI usable without breaking the dev loop.

Summaries

Long plot synopses are compressed on demand by Azure AI Language, giving users a readable at-a-glance version without losing the original. The FastAPI backend brokers the call so keys never touch the browser, and the result is cached against the source title to keep repeat reads instant.

Translation

Azure Translator layers on top of summaries and chat — any reply can be translated into another language without leaving the page. Source and target languages are picked client-side, but the call itself is routed through the backend so credentials stay server-side.

Ratings & Recommendations

Users rate what they watch, and those ratings feed a recommendation service that surfaces titles matching their taste. It's a small feedback loop, but it ties the whole app together — search becomes library, library becomes signal, signal becomes suggestions.

Infrastructure & Deployment

The entire Azure footprint — Foundry account, Foundry project, model deployment, Language resource, Translator resource — is defined in Terraform under the project's `terraform/` directory. A single `terraform apply` produces a ready-to-paste backend env block, and a PowerShell bootstrap script spins up the full dev environment (backend venv, frontend deps, both servers) with one command.

Area Code Blackout Lookup — screenshot 2

Area Code Blackout Lookup — screenshot 3

Summer 2024

SQLTypeScriptJavaScriptHTML/CSSWeb API.NET

Area Code Blackout Lookup

IT Development Intern · National Hockey League

A full-stack internal lookup tool built during an internship at the NHL. The tool provides fast, accurate blackout-status queries via custom Web API endpoints — replacing a sluggish legacy workflow and improving daily data retrieval for operations staff.

Designed and implemented RESTful Web API endpoints for blackout data
Built a responsive front-end with real-time query feedback
Worked across a SQL + TypeScript / JavaScript stack end-to-end
Delivered a complete, production-ready solution within the internship timeline

NHL Page

The Lookup Interface

The front-end delivers instant blackout-status queries by area code. Built with a clean, responsive layout and real-time feedback, it replaced a sluggish internal workflow — giving NHL operations staff fast, accurate results with minimal friction.

Results & Data Flow

Each query hits the RESTful Web API and resolves in milliseconds. The results panel surfaces blackout status with clear formatting — designed for daily, high-volume use. The backend in .NET with SQL ensures reliable data integrity across the board.

Professional Experience

During the NHL internship I learned a great deal about working in a professional environment. I frequently had to learn new tools and workflows on the fly and coordinate with multiple teams — operations, data, and engineering — to gather requirements, iterate quickly, and deliver reliable tooling under real-world constraints.

2025

Godot 4.4C#.NETGame DevelopmentRoguelikeTower Defense

RESET

Programmer & Level Designer · Tower Defense Roguelike

A Tower Defense Roguelike made in Godot 4.4 where the player, a wizard-engineer, defends their camp from waves of plague-mutated monsters. Unlike other Tower Defense games, RESET has no unique tower types — tower abilities are determined through Aspects, modular upgrades that players earn for defeating waves. Aspect order matters, so choosing how to lay out your Aspects in the tower is important. I worked as a programmer and level designer, building out map generation, tower placement systems, and wave progression.

Designed and implemented procedural map generation — paths, tower slots, and camp placement
Built the level and wave progression systems driving the core gameplay loop
Contributed to the Aspects system — modular, order-dependent tower upgrades across three suits (Archer, Mage, Tech)
Worked in Godot 4.4 with C#/.NET, picking up the engine from scratch alongside the team
Practiced structured production processes with sprints, standups, and retrospectives across a multi-month dev cycle
Rarity tiers (Common → Legendary) with tuned drop rates that shift across 20+ rounds of play

Prototype

The Core Loop

Start an act, choose a path, set up towers, defeat the wave, receive a reward — repeat. Each map starts with limited tower availability and enemies that grow stronger throughout the night. The loop is tight and readable: towers lock onto enemies automatically, projectiles arc through the air, and the screen tells a clear story of cause and effect every round. Between waves, players choose from three new Aspects to slot into their towers, shaping their strategy on the fly.

Towers & the Aspects System

Towers are bundles of automated enchantments that the player upgrades with Aspects. They begin as basic shells — a single projectile doing low damage, at a moderate fire rate, with high accuracy and small range. Aspects can be placed onto and moved between towers, changing their stats for good and for bad. Aspect order matters: for example, if fire rate is 2, applying a ×2 multiplier then a +2 gives you 6 — but reversing the order gives you 8. That ordering depth is the backbone of RESET's strategy.

Aspect Suits

Aspects are broken down into suits — similar groupings that bump similar stats and work together. Archer aspects increase range, critical hit, accuracy, and knockback at the cost of fire rate and homing. Mage aspects boost splash, poison, and chain damage but reduce fire rate, damage, and accuracy. Tech aspects push fire rate, homing, and slowdown while sacrificing splash and accuracy. Solo, each suit has a clear identity; mixed together, they unlock the real build diversity.

Aspect Rarity

Aspects come in four rarities — Common, Rare, Epic, and Legendary. Commons almost never multiply values and usually have drawbacks equal to their benefits, but they add to pure values that scale with aspect level. Rares mix additive and multiplicative effects with more significant abilities. Epics lean mostly multiplicative and are consistently strong. Legendaries are game changers that greatly affect tower behaviour no matter when you get them. Drop rates shift as rounds progress — early waves are flooded with Commons, but by round 20+ Legendaries have a 10% chance to appear.

Projectiles & How Aspects Shape Them

Every tower fires projectiles, and every projectile inherits its stats from the tower it came from — damage, speed, spread, and any special properties. What makes RESET's projectiles interesting is that Aspects don't just buff numbers; they fundamentally change what a projectile does. Slot in a poison aspect and your shots start applying damage over time on hit. Add piercing and they punch through multiple enemies instead of stopping on contact. Chain damage makes projectiles jump between targets after impact. Homing strength curves shots toward enemies mid-flight. Crit chance and crit multiplier turn any tower into a high-roller. Even spread angle and spread falloff change the feel — a tight gaussian spread plays completely differently from a wide linear scatter. The projectile is where all your Aspect decisions actually come to life on screen.

Abilities

What was difficult about designing abilities was making them feel necessary but not overpowered. They had to feel like an 'oh shit, the world is ending — I need this to save me' moment. All abilities have levels 1–10, scaling in power as they're upgraded.

Inferno

Area-over-time damage that punishes clustered enemies. As it levels up, the radius expands and damage intensifies — turning a small campfire into a raging firestorm.

Production & Lessons Learned

We ran structured sprints, standups, and retrospectives throughout the project. The biggest setback was losing a core team member partway through the semester — it cost us roughly two weeks of development on key systems and forced us to redistribute work on the fly. The most salient lesson: when you lose people, you have to be aggressive about recovering. We also learned that engine choice matters enormously — Godot let us move faster than Unity would have, even though we were less comfortable with it starting out. The game shipped with a strong foundation, and the team is continuing development.

Spring 2026

Azure AI FoundryAzure AI VisionAzure AI Document IntelligenceAzure AI SpeechAzure AI LanguageAzure AI TranslatorPrompt EngineeringOllamaLocal LLMsPythonNode.js

Enterprise AI Systems

Azure AI Stack · 9 Projects · RIT SWEN 566

A nine-project tour through Azure's AI stack, built across RIT's SWEN 566 — Enterprise AI Systems. Each module ships against a different service: conversational agents on Azure AI Foundry, custom vision and OCR on Azure AI Vision, document intelligence over real-world receipts, speech-to-text and text-to-speech on Azure AI Speech, plus on-demand summarization and translation. A hands-on map of the tooling powering enterprise AI integration.

Conversational agent combining Azure AI Foundry with a local Ollama model for hybrid online/offline inference
Azure Custom Vision project — end-to-end training pipeline for a multi-class jellyfish classifier
Object detection + OCR modules built on Azure Computer Vision for real-world image analysis
Receipt parser using Azure Document Intelligence with normalised pricing and abbreviation expansion
Text summarization and multi-language translation via Azure Language and Azure Translator
Voice interface built on Azure Speech — speech-to-text, text-to-speech, and recorded clip analysis

Conversational Agents

Two agents explored different sides of the same problem. One wires Azure AI Foundry prompt agents into a full Python pipeline, managing versions and deployments. The other runs locally against an Ollama model with a hand-curated library of books, albums, and songs — a reminder that not every good AI system needs a cloud round-trip.

Computer Vision

Three separate modules covering the full Azure vision stack. The training project builds a Custom Vision classifier from scratch — uploading images, tagging them, iterating on the model, and publishing a named prediction endpoint. The object detection module consumes that endpoint in production-style inference. The OCR module layers in text extraction for documents and signage.

Document Intelligence

A receipt parser built on Azure's Document Intelligence service. It ingests a folder of real-world receipts, extracts line items, expands cryptic grocery abbreviations into readable names (gv → Great Value, bkf st → Breakfast Sandwich), and tallies totals — a practical glimpse into how enterprise document pipelines turn messy scans into structured data.

Language Services

Two focused utilities. The summarizer compresses long-form text through Azure AI Language, while the translator module routes content through Azure Translator across source and target languages. Both are simple by design — the goal was to exercise the services cleanly and show how they drop into a larger app's backend.

Speech & Foundry Activities

The voice module works with Azure Speech — recording sound clips, running speech-to-text, and generating synthesised audio responses. Alongside it, the MS Foundry activities explore the same prompt-agent workflow from both Python and Node.js, giving a feel for how Foundry fits into polyglot enterprise environments.

2024

JavaScriptTypeScriptHTML/CSSCanvas APIWeb Audio APIMapbox GL JSWebpackES ModulesBulma CSS

Web Development Fun

IGME-330 Coursework · RIT

A collection of interactive web projects built during IGME-330 at RIT — Rich Media Web App Development. Projects covered the Canvas API, Web Audio API, procedural generation, custom map visualisation, and JavaScript module bundling — each one a focused deep-dive into a different corner of the browser platform.

Built a custom Audio Visualizer with real-time frequency analysis, EQ controls, and canvas effects
Explored procedural generation through Algorithmic Botany — sine waves and phyllotaxis spirals
Created an interactive Canvas Screensaver with animated shapes and spraypaint interactions
Mapped RIT coffee spots using Mapbox GL JS with custom markers and camera transitions
Bundled ES modules with Webpack for a clean, dependency-managed Greeter app
Developed a Technobabble generator — random sci-fi text from composed vocabulary sets

GitHub Pages · Live Explore All Projects

8 interactive web projects live on GitHub Pages — Audio Visualizer, Procedural Botany, Mapbox Maps, and more.

JavaScriptTypeScriptHTML/CSSCanvas APIWeb Audio API +4 more

Audio Visualizer

The centrepiece of the course. A real-time music visualizer built on the Web Audio API and Canvas API — frequency and waveform modes, bars and circles rendered each frame, image-processing effects like colour inversion and emboss, bass and treble EQ sliders, and full-screen support. The app accepts any local MP3 file alongside a default track, and the whole visual theme was built around Mew and Mewtwo.

Algorithmic Botany

Two procedural generation explorations: the first uses sine waves to grow branching plant-like structures across the canvas; the second applies phyllotaxis — the same mathematical spiral that governs sunflower seeds and pine cones — to scatter dots in controlled, organic patterns. Both were purely canvas-driven with interactive parameter controls.

Canvas Screensaver & JS Canvas

An animated screensaver that continuously draws and composites rectangles, arcs, and lines across the canvas. Play/pause/clear controls let you manage the animation loop, while clicking anywhere in paused mode 'spraypaint' shapes at the cursor — a hands-on exercise in canvas compositing and event-driven interactivity.

RIT Coffee Finder

A Mapbox GL JS project that plots custom markers across the RIT campus for nearby coffee spots. Buttons smoothly transition the camera between preset views — standard overhead, isometric angle, street-level zoom, and a global pullout — demonstrating custom marker data, GeoJSON loading, and programmatic camera control.

Webpack & ES Modules

A Greeter app that demonstrated the full JavaScript module bundling workflow with Webpack. The project separated concerns cleanly across ES modules — greeter logic, UI handling, and entry point — then bundled them into a single optimised output. A practical intro to the build tooling that underpins modern front-end development.

Fall 2024

UnityC#Game Development2DTeam Project

Astro Outlaw

Planet Stage Developer & UI · Team Indiecisive

A space-pirate adventure game built by a six-person team. Players explore alien planets to gather resources and upgrade their ship, then fight through waves of enemies in bullet-hell-style space combat to reach the ultimate treasure.

Built planet exploration stages with resource gathering and traversal mechanics
Implemented the in-game shop UI and menu flow end-to-end
Collaborated across a six-person team (Indiecisive) with consistent sprint cadence
Dual-mode gameplay loop: calm planet exploration → frantic bullet-hell combat
Created and published an itch.io page and presskit for public release
Post-mortem reinforced lessons on scope management and cross-team communication

itch.io

The Shop System

Between battles, players stop at the ship shop to upgrade weapons, hull plating, and propulsion modules. The shop UI was designed to be scannable mid-session — clear categories, visible stat deltas, and a satisfying purchase flow that rewards smart resource management.

NPC Interactions

Friendly NPCs are scattered across planet stages, adding narrative texture to the exploration loop. They range from quest givers to merchants, weaving a loose storyline through the game's otherwise combat-heavy progression.

Enemy Encounters

Waves of hostile ships flood the viewport in escalating difficulty. Each enemy type has distinct movement patterns and attack profiles, forcing players to read the battlefield and adapt their approach with every encounter.

Boss Encounters

Later stages introduce larger, more aggressive enemy variants that demand precise positioning and upgraded firepower. These encounters are the natural payoff for the grind — bigger ships, bigger rewards, bigger challenge.

Summer 2025

SvelteKitTypeScriptTailwind CSSStripeDaisyUIViteBrand Design

Perfect Powerlifting

Founder & Developer · Coaching Brand & E-Commerce Platform

A full-stack coaching brand and e-commerce site built to scale a personal powerlifting coaching operation. What started as helping teammates on RIT's powerlifting team grew to coaching 12 athletes simultaneously — demanding a real brand, real infrastructure, and real products. Perfect Powerlifting is the result.

Built a Stripe-integrated e-commerce shop selling downloadable training programs
Designed the full brand identity — wordmark, emblem, and lettermark in black, white, and gold
Google Sheets-backed program delivery on purchase via Stripe webhooks
Six programs spanning beginner through advanced powerlifting, bodybuilding, and meet peaking
Coached 12 athletes simultaneously — custom programs, meet handling, form review, and diet guidance
Athletes added 290 lbs to their total in a year, competed at nationals, and broke personal records

powerliftingperfect.com

Why Perfect Powerlifting Exists

It started simple — I wanted to help my teammates on RIT's powerlifting team. That grew fast. At peak I was coaching 12 athletes at once: writing fully customized programs for each, reviewing lift footage at home and in the gym, constant text updates on form and diet, coaching at meets as a handler, and providing emotional support through the grind. I needed a brand that matched those ambitions, so I built one.

The Shop & Program Delivery

The e-commerce side runs on Stripe with full webhook integration. When a lifter purchases a program, a webhook fires, validates the payment, and delivers a custom Google Sheets training document directly to their inbox. Programs run from $30–$40 and cover beginner through advanced powerlifting, hypertrophy, and meet peaking. The shop is clean, fast, and built to convert.

Coaching Results

John D. went from a 1235 total to a 1525 — a 290-pound improvement in just over a year, with measurable squat form corrections along the way. Lauren M. added 100 lbs to her total in 16 weeks and competed at nationals in the 60kg Junior Raw class. Chase B. holds a 1282 total and continues to climb. Every program is built around the athlete's equipment, schedule, and goals — no templates, no guesswork.

The Brand

Perfect Powerlifting needed a visual identity that felt premium and earned. I built the brand from the ground up — wordmark, emblem, and lettermark, each in black, white, and black-and-gold. The animated logo was designed to open the site with impact. The palette and typography reference the sport's culture of discipline and earned excellence.

2025

UnityC#Game Development2DPrototype

No Signal

Solo Developer · 2D Vertical Climber

A fast-paced vertical climbing game where players race through hazardous, rhythm-synced obstacle courses. Built as a solo prototype exploring tight twitch-based controls, procedural level generation, and satisfying feedback loops.

Rhythm-synced obstacle generation tied to an adaptive beat system
Tuned twitch-based controls for a snappy, responsive feel
Shipped prototype with integrated leaderboard and replay system
Polished particle effects and screen-shake feedback layers

Prototype

Rhythm-Synced Obstacles

The core mechanic: obstacle patterns are generated in lockstep with an adaptive beat system. As the track shifts tempo, so do the platforms and hazards — creating a visceral connection between what you hear and what you dodge.

Procedural Level Design

No two vertical climbs feel the same. The generator weighs difficulty, spacing, and obstacle variety to produce runs that escalate naturally. The result is a game that stays fresh and replayable across dozens of attempts.

Polish & Feedback

Particle bursts on impact, screen shake on near-misses, crisp audio cues on combo streaks. The prototype is a study in how small, well-timed feedback moments compound into a game that feels genuinely alive.