Ethan Jordan

Virtius Meet Viewer

I worked on the Virtius scores project as the main engineer for my branch, scores.virti.us. I used Next.js 15, React 19, TypeScript, and Tailwind CSS to improve the meet viewer for live NCAA gymnastics scoring.

What I Improved & Learned:

• Next.js Work: Worked with App Router patterns, React components, TypeScript data, Tailwind UI, and real bugs inside an existing app.
• Performance: Improved load speed with better rendering choices, lazy loading, and cleaner data flow.
• GraphQL & Request Flow: Studied how virti.us moved live scoring data through GraphQL requests and used that to make better decisions.
• Scoring Accuracy: Helped solve real scoring problems like floating-point precision, dynamic 3/4-decimal display, exhibition athlete filtering, and edge-case ranking behavior.
• Security Mindset: Kept security in mind while working with API data, request flow, caching, and the boundary between the client and server.
• Testing Discipline: Worked with Playwright tests, visual comparisons, and regression checks so changes were backed by more than just clicking around and hoping.

The main lesson was how to work inside a real product: understand the codebase, talk through tradeoffs, improve performance, and still care about correctness and security.

AVAC Tennis Class Automation

At AVAC, I saw how much time tennis staff spent on repetitive enrollment work. I built a Python tool to automate the boring parts and flag the cases that still need a person.

The project started with class rosters and enrollment. I added attendance checks, CSV comparison, and prompts for cases where the program should not guess.

How I Made It Work:

• Python + Selenium: Automated login and enrollment steps in the Club Automation site.
• Pandas & CSVs: Compared player lists, attendance logs, and inquiry files.
• Human Review: Added prompts when the tool finds a case that needs staff judgment.
• Setup: Wrote a batch script so staff could run it without manually setting up the environment.

This was a good lesson in practical software. The tool only mattered because it fit the real workflow and handled edge cases instead of pretending they did not exist.

Linux & Security Tool Lab

I have been using Linux since freshman year of high school through live boots and full installs. I have used Kali, Arch, and Linux Mint, and I spent a lot of time learning how security tools behave in lab and authorized environments.

What I Practiced:

• Linux Installs: Booted and installed different distributions, fixed driver/config issues, and learned how Linux systems are laid out.
• Kali Linux: Used Kali as a security-focused environment and focused on understanding what the tools were actually doing.
• Network Scanning: Practiced with Nmap to understand hosts, ports, services, and why exposed services matter.
• Metasploit Basics: Spent time learning how modules, payloads, and lab exploitation workflows are structured.
• System Comfort: Got comfortable with the terminal, packages, permissions, services, network settings, and troubleshooting broken installs.
• Security Mindset: Learned to think in terms of attack surface, misconfiguration, and verification instead of just running tools.

The useful part was not memorizing commands. It was learning how Linux, networks, and security tools fit together, and how to slow down enough to understand what a tool is actually showing me.

Raspberry Pi Pi-hole Network Lab

I set up Pi-hole on a Raspberry Pi to learn how DNS, DHCP, IPv4, IPv6, and router control work on a real home network. The goal was network-wide ad blocking. The useful part was figuring out why the Xfinity gateway kept bypassing it.

What I Built & Learned:

• Raspberry Pi Server Setup: Installed Pi-hole headlessly, reserved 10.0.0.50, set Cloudflare as upstream DNS, and tested it with nslookup.
• DNS Debugging: Queried Pi-hole directly, then checked the dashboard to prove requests were reaching the server.
• DHCP vs DNS: Learned the difference between resolving names and assigning network settings, and why controlling DHCP is what lets you control where devices send DNS traffic.
• Xfinity Router Limits: Found that the stock gateway would not reliably allow custom network-wide DNS, so devices kept falling back to Comcast DNS like cdns01.comcast.net.
• IPv6 Bypass: Tracked how Xfinity IPv6 DNS, including 2001:558:feed::1, could silently bypass Pi-hole even when IPv4 settings looked correct.
• Risky Change Recovery: Tested a Pi-hole DHCP takeover, hit router/DHCP conflicts and temporary network loss, then backed out and isolated the problem instead of guessing.

This taught me more because it did not go perfectly. I learned to test one layer at a time, separate a working service from a router problem, and think before changing settings that affect the whole network.

Backward Propagation Neural Network

I built a neural network from scratch in Python because I wanted to understand what backpropagation was actually doing. I spent the quarter working through the math, writing the code, and debugging it until the model could learn from data.

Along the way, I got hands-on with:

• Feedforward and Backpropagation: Wrote the prediction step and the weight update step using gradients. Debugging this was the hard part.
• Activation Functions: Tested ReLU, Sigmoid, and Tanh to see how they changed learning.
• Preventing Overfitting: Tried regularization and dropout so the model would not only memorize the training data.
• Matrix Math & Python Libraries: Used NumPy and vectorized operations to make the code faster and cleaner.

This project made machine learning feel less mysterious. It forced me to slow down, test each step, and understand why the model was or was not learning.

Mattercam Project

I built a dashboard that shows a Disneyland livestream and current ride wait times. It started as a Raspberry Pi idea, but I later moved it toward Windows because the Pi did not have enough memory for the full app.

What I Built & Learned:

• Custom Tkinter UI: Built a simple fullscreen interface with color-coded ride times.
• Web Scraping: Used BeautifulSoup and Requests to pull wait-time data and parse messy HTML.
• Live Video Streaming: Used yt-dlp and VLC to load the webcam feed inside the app.
• Real-Time Updates: Refreshed the data every minute and showed the last update time.

This project taught me how to combine scraping, media playback, and UI code. A lot broke while I was building it, which made the debugging useful.

BinaryTree Class (Python Data Structures)

I implemented a binary search tree in Python to understand inserts, search, deletes, traversals, recursion, and edge cases.

I implemented a binary search tree in Python to understand the data structure beyond just drawing it on paper. I wrote the operations, tested edge cases, and added a small menu to try the tree from the terminal.

What I Focused On:

• Core BST Operations: Built insert, search, and delete, including cases like deleting the root.
• Tree Traversals: Added in-order, pre-order, and post-order traversal.
• User Interaction: Added a text menu so the tree could be tested without editing code.

This helped me understand recursion, class design, and why edge cases matter in basic algorithms.

Python Computer Inventory Manager

I built a command-line inventory app for Linux and Windows machines using Python, SQLite, OOP, validation, and a terminal menu.

I built this command-line app to track computers for a small IT-style inventory. It stores Linux and Windows machines, saves them in a database, and checks input before accepting it.

What I Learned & Built:

• Python + SQLite3: Stored inventory data in a persistent database.
• OOP Design: Used classes and inheritance for different computer types.
• Input Validation: Checked IP addresses before saving them.
• Interactive Menu: Built a terminal menu for adding, updating, and removing computers.

This was a good practice project for OOP, databases, validation, and making a tool understandable for someone besides the person who wrote it.

RTSP 4-Camera Viewer

I built a desktop app that shows up to four RTSP camera feeds at once while learning video streams, VLC, and custom window behavior.

I built a desktop app that shows up to four RTSP camera feeds at once. It was mostly about learning video streams, window behavior, and how to keep a monitoring tool usable.

Technical Implementation:

• VLC Integration: Used python-vlc to load RTSP streams and tune caching settings.
• Custom Tkinter UI: Built a borderless window, custom title bar, draggable interface, and 2x2 feed layout.
• Window Controls: Added fullscreen, dragging, F11, and Escape behavior.
• Stream Settings: Adjusted VLC parameters for live camera feeds, including caching and clock sync.

This project taught me how much small settings matter when video comes over a network. A camera app can look simple, but stream handling and timing make it interesting.