About
Hi, I'm Mitchell. I’m a software engineer who builds applications and infrastructure with the people who use and operate them in mind. My experience spans cloud platforms, business software, and systems research, with a focus on reducing manual work and making complex workflows easier to run and maintain. I bring that same practical approach to engineering leadership and technical mentoring, helping teams understand and improve the systems they work with.
I earned my M.S. in Computer Science at the University of California, Santa Cruz, where I created CarbonStream, an end-to-end total cost of carbon analyzer for data centers. My research evaluated the environmental impact of storage technologies through lifecycle analysis and combined cost, performance, and sustainability metrics in a storage-optimization framework. At UCSC’s Center for Research in Systems and Storage, I also evaluated storage architectures through repeatable trace-driven experiments and led a three-person engineering team operating shared research infrastructure on NRP Nautilus Kubernetes with Ceph-backed storage.
As Head Teaching Assistant for CSE 130: Principles of Computer System Design, I supported a course serving 1,000+ students across six quarters. I coordinated teaching staff, developed programming assignments, and taught modular C/C++ systems software, concurrency, networking, memory management, testing, and debugging. I built GitLab CI/CD submission checks and operated full assignment grading in Docker on a local Ubuntu VM, reducing estimated overall grading time by 50%.
My industry work includes a manufacturing planning application, production operations across 100+ Kubernetes clusters, AWS migrations and CI/CD pipelines, and operational dashboards. Across these projects, I work with users and teammates to translate practical needs into software and infrastructure they can run and maintain.
Experience
UCSC Center for Research in Systems and Storage
Research Software Engineer, Platform Infrastructure
- Led a 3-person engineering team developing and operating shared infrastructure for systems research, coordinating platform architecture, implementation, code review, and experiment support across parallel lab projects.
- Built and maintained containerized research environments on NRP Nautilus Kubernetes with Ceph-backed persistent storage for repeatable compute- and data-intensive workloads across multiple users.
- Standardized deployment, configuration, data-access, and experiment workflows across Kubernetes, Ceph, BigQuery, DuckDB, and Parquet to reduce environment-specific setup and improve research reproducibility.
- Developed reusable self-service operational tooling for launching, monitoring, and managing long-running experiments, improving resource utilization while avoiding thousands of dollars in equivalent GCP compute costs.
UCSC Center for Research in Systems and Storage
Research Software Engineer, Storage Systems
- Evaluated storage architectures across device classes and workload patterns, analyzing performance, capacity, energy, and cost tradeoffs to guide infrastructure design decisions.
- Designed repeatable trace-driven workflows for comparing storage technologies under realistic demand, standardizing inputs, parameter sweeps, validation, and result review across configurations.
- Collaborated with systems researchers to translate open-ended research questions into measurable experiments and synthesize results into storage-architecture recommendations.
University of California, Santa Cruz
Graduate Student Researcher
- Created CarbonStream, an end-to-end total cost of carbon analyzer for data centers, for M.S. research.
- Evaluated the environmental impact of data-center storage technologies through lifecycle analysis.
- Developed a storage-optimization framework integrating cost, performance, and sustainability metrics.
- Identified opportunities to improve hybrid storage energy efficiency through workload-specific strategies.
Perfectly Snug
Software Engineer Intern
- Developed a material requirements planning (MRP) application using Python, Node.js, React, and SQL, integrating inventory, customer orders, bills of materials, and production data into a single internal system.
- Built dashboards for inventory availability, material requirements, order status, and production progress; automated reconciliation and scheduling, reducing manual planning time by roughly 50%.
- Worked directly with manufacturing stakeholders to gather requirements, iterate on operational workflows, debug edge cases, and translate production needs into maintainable internal software.
- Developed dashboards and reports using Shopify API data to support daily manufacturing build plans.
- Integrated product-testing software into a mobile application to streamline the build procedure.
ParkourSC, Inc.
DevOps Engineer Intern
- Operated production cloud and platform infrastructure for a supply-chain application deployed across 100+ Kubernetes clusters, spanning IoT ingestion, Kafka, Spark, Cassandra, Elasticsearch, and web services.
- Created and tuned New Relic alerting policies using NRQL, reducing false-positive production alerts by approximately 80% across distributed services.
- Worked with developers to improve incident resolution and alert-tuning workflows, standardizing how alerts were reviewed, adjusted, and escalated during production operations.
- Automated monitoring for Kubernetes continuous delivery and cluster upgrades, integrating New Relic and Jira to suppress maintenance-related alerts while preserving operational context.
- Investigated outages across application, platform, and cloud infrastructure layers by tracing deployment topology and service dependencies and correlating Kubernetes state, dashboards, metrics, logs, alert incidents, and NRQL queries across Spark, Kafka, Cassandra, and Elasticsearch.
uLab Systems, Inc.
Site Reliability Engineer Intern
- Migrated a production application from Lightsail to EC2 and operated its AWS infrastructure with CloudWatch instance-health monitoring, improving deployment flexibility, operational control, and maintainability.
- Built a secure AWS environment using VPC, Elastic Load Balancing, and IAM access controls, managing network isolation and permissions for cloud resources and services.
- Integrated Datawiza Access Broker with Okta, implementing centralized authentication and proxy-based access controls for the production application while filtering unwanted web traffic.
- Wrote a Python script to copy objects and preserve Access Control Lists (ACLs) between Amazon S3 buckets, automating data migration while retaining object-level permissions.
- Designed and implemented a three-stage CI/CD pipeline using GitHub, AWS CodeBuild, and Amazon ECS for development, validation, and production, reducing manual release work and improving deployment consistency.
- Used Terraform for repeatable AWS infrastructure provisioning and configuration, and documented provisioning, deployment, and recovery workflows in operational runbooks.
Nevtec, Inc.
Data Analyst Intern
- Created a real-time ticket-monitoring system using Power BI and SQL against ConnectWise service data, building operational dashboards for Nevtec's CEO and IT support team.
- Wrote Power BI Data Analysis Expressions (DAX) scripts to create calculated columns and transform operational service datasets.
- Analyzed service-ticket data to compare engineer efficiency, customer IT request patterns, and time spent resolving different types of support tickets.
- Built dashboards reporting ticket response and closing times, billable hours, and project time utilization.
- Provided dashboard metrics showing when service-level-objective policies were met or violated.
Nevtec, Inc.
Computer Technician Intern
- Configured dozens of customer PCs and automated their setup using Windows Server, PowerShell, XML, and batch scripting, eliminating manual installation clicks and configuration of custom options.
- Reduced setup time for an entire batch of PCs to the order of minutes, compared with several hours when machines were configured individually.
- Documented tables and their relationships in Nevtec's ConnectWise database, extending the limited basic vendor documentation and public information previously available.
- Cataloged previously undocumented custom data in the ConnectWise database to support internal understanding of enterprise datasets.
Teaching
University of California, Santa Cruz
Head Teaching Assistant – CSE 130: Principles of Computer System Design
- Served as Head Teaching Assistant for CSE 130 across six quarters, mentoring teaching staff and supporting an upper-division computer system design course serving 1,000+ students.
- Coordinated course delivery and staff responsibilities around competing priorities and scheduling conflicts; standardized documentation, grading workflows, issue escalation, onboarding, and staff coverage.
- Built and maintained GitLab CI/CD infrastructure for systems-programming assignments, automating compilation, testing, and feedback workflows and reducing estimated overall grading time by 50%.
- Developed programming assignments and led discussions on concurrency, networking, memory management, and reliable C/C++ systems software; taught students to design clean, modular, well-organized programs and to use and create reusable libraries.
- Taught students to build debugging and testing harnesses, identify edge cases, and write unit, regression, and end-to-end tests that verify specific program behavior.
- Provided a subset of assignment tests and directed students to develop additional tests; individual cases targeted specific functionality or edge conditions, with most difficult cases hidden from students.
- Guided runtime investigation with GDB, Linux perf, /proc inspection, shell piping, logging, and print debugging to understand execution behavior and identify performance bottlenecks.
- Taught diagnosis of multithreading, synchronization, thread safety, command and string parsing, NULL pointer dereferences, network failures, improper file I/O, bad file descriptors, and errors reported by function and system-call return values.
University of California, Santa Cruz
Undergraduate Course Tutor
- Tutored students on programming assignments for CSE 130: Principles of Computer System Design.
- Reviewed course material and taught practical programming and debugging techniques to students.
- Assisted teaching assistants during discussion sections and office hours for systems coursework.
Projects
Research platforms, developer tools, distributed systems, and application projects. Each entry describes the implementation and its context.
Research, systems, and application projects
Workload Trace Analysis Platform
A research data platform that turns multi-month Google cluster and power traces into reusable, simulator-ready datasets.
- Built a data-processing platform for multi-month Google cluster and power traces stored in Google Cloud Storage, using BigQuery to select and extract bounded source datasets into repeatable local analysis workflows.
- Materialized extracted traces as Parquet and used DuckDB to query, transform, join, and validate reusable datasets without repeatedly scanning the complete remote source.
- Created CLI and automated testing workflows to orchestrate dataset selection, BigQuery extraction, Parquet conversion, DuckDB processing, schema validation, and packaging of simulator-ready inputs.
SimOps Workbench: Simulation Experiment Dashboard
A TypeScript and React dashboard that makes dynamics-simulation experiments easier to configure, monitor, reproduce, and compare.
- Built a TypeScript and React self-service dashboard around a dynamics simulator, turning one-off runs into repeatable workflows for configuring scenarios, monitoring execution, and comparing telemetry.
- Integrated Flask APIs and SQLite-backed experiment history with parameter-sweep and batch workflows, allowing completed experiments to be reopened, reproduced, and compared.
- Added interactive telemetry comparisons, JSON and CSV exports, printable reports, and Docker Compose workflows to improve analysis, sharing, and reproducibility.
CogniStore: AI-Powered Data Lifecycle Manager
A storage-management platform combining a common lifecycle API, semantic metadata retrieval, and automated placement policies.
Public repository link pending
- Developed an intelligent data-management platform unifying file, block, and object storage behind a common API for lifecycle management across heterogeneous storage services.
- Built a modular storage abstraction layer integrating PostgreSQL with pgvector, OpenSearch, and Redis for metadata persistence, semantic indexing, and low-latency retrieval.
- Implemented an AI-driven policy engine for automated data placement across storage tiers based on lifecycle, cost, performance, and sustainability goals.
- Used GitHub Actions in the project's CI/CD process to run automated tests.
CarbonStream: Data Center Carbon TCO Simulator
A Python trace-driven simulator, originating in my M.S. research, for comparing heterogeneous storage architectures across performance, capacity, energy use, and carbon impact.
- Built a Python trace-driven simulator for evaluating performance, capacity, energy use, and carbon impact across heterogeneous data-center storage architectures.
- Modeled workload behavior using device latency, throughput, power, lifespan, capacity, and regional carbon-intensity inputs under changing demand.
- Implemented bottleneck detection, service-level-objective checks, configuration search, parameter sweeps, and automated CSV and visualization outputs for reproducible analysis.
- Used perf, fio, gem5, and SimpleSSD in SSD simulation work and to prototype an early version of the CarbonStream TCO simulator; used Flamegraphs to visualize perf data.
- Recorded SSD I/O traces with blktrace and used other workload traces in blktrace format as source inputs to the early CarbonStream simulator.
- Used Grafana and Prometheus to view historical Wikipedia data for CarbonStream.
Automated Grading Infrastructure
Developed and maintained submission checks, containerized grading, and feedback workflows for a course serving 1,000+ students. The work combined my own implementation with shared course infrastructure and coauthored tests; I estimate it reduced overall grading time by approximately 50%.
- Maintained GitLab runner checks for Make compilation, clang-format, and required files. Maintained reusable CI YAML with one build stage, using TESTING_DOCKER_IMAGE to select the Docker image and CI_USER, CI_TOKEN, and CI_REPO to clone centralized CI scripts.
- Added a Python CI entrypoint that selected an assignment from Git history, integrated centralized grader scripts and recursive submodules, and propagated validation failures through the job exit status. Added a conditional grading bypass returning success when the history scan encountered a notes path before an assignment path.
- Operated full assignment grading in Docker containers on a local Ubuntu VM because school IT servers lacked capacity. Automated repository preparation and full-grader execution with Python and Bash batch workflows, reducing estimated overall grading time by 50%.
- Built a Python utility to compare grading runs, identify missing or higher, lower, and equal results, and summarize scores with mean, median, and mode using the statistics module.
- Built a Python merger comparing two grading runs and selecting each student's entire higher-total rubric file, retaining entries present in only one run and reporting reconciliation decisions and statistics.
- Operated score-processing workflows using the shared PLY lex/yacc parser to read structured grading rubrics, scores, and comments; automated publication of rubric scores and feedback to Canvas LMS through Python canvasapi integration and batch upload wrappers.
- Authored a configurable C reader/writer-lock test harness using pthread mutexes and condition variables for coordinated starts and exclusion checks, with per-thread counts and reader/writer priority ratios. Expanded stress and priority testing through N=100 with 50 reader and 50 writer threads.
- Expanded file-I/O tests for large and binary payloads, missing content lengths, and failed writes, checking output contents, diagnostics, and exit status. Corrected randomized request-size bounds in an existing LD_PRELOAD/dlsym partial-I/O shim intercepting libc read, write, and close calls.
- Added HTTP parsing and data-integrity tests for request syntax, headers, content lengths, and error cases using curl and a supplied raw TCP client. Collaboratively extended HTTP server-error tests with LD_PRELOAD/dlsym filesystem-error shims and exact HTTP 500 response checks.
- Added partial-GET/full-PUT and partial-PUT/full-GET interleaving workloads to concurrent HTTP extra-credit grading, reusing the existing workload execution, audit-order validation, and response-state checks.
- Maintained Python assignment handlers and TOML configurations for required files, test preparation, rubrics, timeouts, and cleanup. Used Clang and Make to build C harnesses; maintained shared checks for Makefile targets, executables, warning flags, and compilation commands, and operated Valgrind memory-error and leak checks on submitted C programs.
- Coauthored standalone queue pop-validity and push-order tests and added pthread linkage to concurrent-queue test wrappers.
- Documented repository preparation, full and targeted grading, score review and upload, and commands for comparing and reconciling results.
NRWLock: Thread-safe Reader-Writer Lock
A C synchronization library for coordinating concurrent readers and writers that share a resource, including intended use in multithreaded web servers.
- Developed a thread-safe reader-writer lock library in C using POSIX mutexes and condition variables.
- Implemented configurable N-Way blocking for concurrent reader and writer access.
- Designed priority scheduling policies with fairness, throughput, and starvation avoidance as goals.
In-Memory File System
A Unix-style filesystem simulation in C++ that combines an in-memory hierarchy with an interactive terminal shell.
In-Memory File System on GitHub
- Built a Unix-style in-memory filesystem with a tree-structured hierarchy in C++.
- Implemented command support in a shell environment using GNU Core Utilities-style semantics.
- Managed an inode tree with root, directory, and file mappings for filesystem operations.
Multi-Server File Replication System
A concurrent UDP client for replicating files to multiple servers while handling unreliable packet delivery in application-level protocol logic.
- Implemented concurrent transmission of file data to multiple destination servers over UDP.
- Built a custom sliding-window protocol with retransmission tracking to handle packet loss and reordering during transfers.
- Logged per-packet timestamps, IP addresses, ports, and sequence numbers to support debugging and analysis across participating servers.
Distributed Key-Value Store
A Go distributed key-value store that evolves an in-memory HTTP API into a system with causal consistency, replication, and sharding.
- Built a Go in-memory key-value store with causal consistency, sharding, and replication.
- Implemented reverse-proxy request forwarding, replica-to-replica HTTP handlers, and concurrent broadcast paths for replication and failed-replica view updates.
- Implemented vector-clock operations and shard-aware routing that directed writes to the owning shard and replicated them within that shard.
Software-Defined IPv4 Router
A Mininet-based enterprise-network simulation for exploring IPv4 routing, host isolation, and traffic policy across subnets.
- Designed a multi-floor network topology with isolated, trusted, and untrusted hosts to model different communication boundaries.
- Implemented a custom POX controller for inter-subnet routing and firewall rules using TCP/IP and ICMP traffic filtering.
- Validated connectivity and network segmentation through repeatable Mininet and Wireshark tests.
DDFS: Deduplicating Block Storage System
A deduplicating block storage system for FreeBSD, implemented in C with hashed addressing, persistent metadata, and unique blocks stored on a mounted memory disk.
DDFS: Deduplicating Block Storage System on GitHub
- Built a deduplicating block storage system for FreeBSD in C using hashed addressing.
- Mapped 160-bit keys to unique 4 KiB blocks stored on a mounted memory disk.
- Designed persistent metadata structures, inode-management workflows, and block-allocation logic; used a superblock to store filesystem metadata and inodes to contain mappings to data blocks.
- Implemented address translation and data-retrieval logic below high-level storage APIs.
Unix Shell
A custom shell in C with Flex-based token parsing and separate components for command interpretation, process execution, and input/output handling.
- Created a Unix shell supporting single and piped commands, I/O redirection, and built-in commands.
- Implemented return-value validation and error handling for command execution and malformed input.
- Used Flex for token parsing alongside modular process-management and redirection logic.
MRPC: Multithreaded RPC Server
A remote procedure call server that combines concurrent socket handling, server-side file operations, and persistent key-value storage.
MRPC: Multithreaded RPC Server on GitHub
- Implemented a multithreaded RPC server supporting concurrent socket-based client requests.
- Designed a custom client-server protocol with requests and responses transmitted in network byte order.
- Developed request processing with recursive name resolution, error handling, and persistent key-value storage.
- Implemented RPC arithmetic operations and server-side file creation, reading, writing, and file-size queries.
Jake's Hockey Pool
A hockey-pool application connecting an external live NHL data feed to application state and pool workflows.
- Created a live data-feed interface mapping to the undocumented NHL REST API.
- Contributed to data structures and schema design for application state and pool workflows.
- Applied modular programming practices to streamline development, testing, and architecture review.
LZW File Compressor
A command-line C tool implementing lossless LZW compression and decompression for text and binary files.
- Developed an LZW compression and decompression tool in C for lossless text and binary file handling.
- Implemented buffered I/O and variable-length codes for file compression and decompression.
- Structured the implementation with modular abstract data types for tries and word tables.
Projects from professional work
Implementation work completed within the roles listed above. These headings describe work initiatives within those internships.
Material Requirements Planning System
An internal application bringing inventory, customer orders, bills of materials, and production data into one manufacturing-planning workflow.
- Developed a material requirements planning (MRP) application using Python, Node.js, React, and SQL, integrating inventory, customer orders, bills of materials, and production data into a single internal system.
- Built dashboards for inventory availability, material requirements, order status, and production progress; automated reconciliation and scheduling, reducing manual planning time by roughly 50%.
- Worked directly with manufacturing stakeholders to gather requirements, iterate on operational workflows, debug edge cases, and translate production needs into maintainable internal software.
- Developed dashboards and reports using Shopify API data to support daily manufacturing build plans.
Product-Testing Mobile Integration
A mobile integration supporting the product-build workflow during the manufacturing software internship.
- Integrated product-testing software into a mobile application to streamline the build procedure.
Production Monitoring and Alert Automation
Production infrastructure and observability work for a supply-chain application deployed across 100+ Kubernetes clusters.
- Operated production cloud and platform infrastructure for a supply-chain application deployed across 100+ Kubernetes clusters, spanning IoT ingestion, Kafka, Spark, Cassandra, Elasticsearch, and web services.
- Created and tuned New Relic alerting policies using NRQL, reducing false-positive production alerts by approximately 80% across distributed services.
- Worked with developers to improve incident resolution and alert-tuning workflows, standardizing how alerts were reviewed, adjusted, and escalated during production operations.
- Automated monitoring for Kubernetes continuous delivery and cluster upgrades, integrating New Relic and Jira to suppress maintenance-related alerts while preserving operational context.
- Investigated outages across application, platform, and cloud infrastructure layers by tracing deployment topology and service dependencies and correlating Kubernetes state, dashboards, metrics, logs, alert incidents, and NRQL queries across Spark, Kafka, Cassandra, and Elasticsearch.
AWS Migration and Deployment Infrastructure
An application migration and delivery workflow covering AWS infrastructure, access controls, data movement, and repeatable deployments.
- Migrated a production application from Lightsail to EC2 and operated its AWS infrastructure with CloudWatch instance-health monitoring, improving deployment flexibility, operational control, and maintainability.
- Built a secure AWS environment using VPC, Elastic Load Balancing, and IAM access controls, managing network isolation and permissions for cloud resources and services.
- Integrated Datawiza Access Broker with Okta, implementing centralized authentication and proxy-based access controls for the production application while filtering unwanted web traffic.
- Wrote a Python script to copy objects and preserve Access Control Lists (ACLs) between Amazon S3 buckets, automating data migration while retaining object-level permissions.
- Designed and implemented a three-stage CI/CD pipeline using GitHub, AWS CodeBuild, and Amazon ECS for development, validation, and production, reducing manual release work and improving deployment consistency.
- Used Terraform for repeatable AWS infrastructure provisioning and configuration, and documented provisioning, deployment, and recovery workflows in operational runbooks.
Service Ticket Monitoring and Dashboards
Operational reporting that connected ConnectWise service-ticket data with dashboards used by Nevtec’s CEO and IT support team.
- Created a real-time ticket-monitoring system using Power BI and SQL against ConnectWise service data, building operational dashboards for Nevtec's CEO and IT support team.
- Wrote Power BI Data Analysis Expressions (DAX) scripts to create calculated columns and transform operational service datasets.
- Analyzed service-ticket data to compare engineer efficiency, customer IT request patterns, and time spent resolving different types of support tickets.
- Built dashboards reporting ticket response and closing times, billable hours, and project time utilization.
- Provided dashboard metrics showing when service-level-objective policies were met or violated.
Workstation Provisioning Automation
Automated setup and configuration of new customer PCs using Windows Server, PowerShell, XML, and batch scripting.
- Configured dozens of customer PCs and automated their setup using Windows Server, PowerShell, XML, and batch scripting, eliminating manual installation clicks and configuration of custom options.
- Reduced setup time for an entire batch of PCs to the order of minutes, compared with several hours when machines were configured individually.
Skills
A comprehensive inventory of technologies, tools, and engineering practices across my work, projects, and coursework.
Programming and query languages
Assembly
Bash
Batch scripting
C
C++
DAX
Go
Java
JavaScript
NRQL
OCaml
PHP
PowerShell
Python
Scheme
Smalltalk
SQL
TypeScript
Software design and development
Abstract data types
Asynchronous workflows
Automated testing
Automated validation
Causal consistency
Code review
Compiler design
Computational models
Computer science education
Data structures and algorithms
Distributed systems
Edge-case identification
End-to-end testing
Error handling
Fault handling
Fault tolerance
Functional programming
LZW compression
Modular programming
PLY
Policy engines
Programming language concepts
Regression testing
Remote execution
Remote procedure calls (RPC)
Replication
Reusable library development
Reverse proxies
Scalable systems
SHA-1
Sharding
Software design
Software testing
System design
Systems analysis
Test harness development
Test suite development
Tries
Unit testing
Variable-length codes
Vector clocks
Word tables
Web development and APIs
Apache
API development
Backend engineering
Bottle
Bulma.css
FastAPI
Flask
Full-stack engineering
GraphQL
gRPC
HTTP services
Internal tools development
MediaWiki
Mobile application integration
Nginx
Node.js
Py4Web
React
REST APIs
Shopify API
Varnish
Vue.js
Web applications
WordPress
Databases and search
Apache Cassandra
Data modeling
Database design
Database systems
DuckDB
Elasticsearch
Google BigQuery
MongoDB
MySQL
MySQL Workbench
NoSQL
OpenSearch
pgvector
PostgreSQL
Redis
Relational databases
Relational schema design
Semantic indexing
SQL Server
SQLite
SSMS
Storage and filesystems
Address translation
AI-driven storage placement policy
Archival storage system design
Block allocation
Block storage
Ceph
Data deduplication
File storage
Filesystem internals
Filesystems
Hashed addressing
Inode management
Key-value storage
MinIO
NFS
NVMe
Object storage
Reference counting
RocksDB
Storage abstraction layers
Storage internals
Storage lifecycle management
Storage optimization
Storage systems
Storage tiering
ZFS
Data engineering and analytics
Apache Kafka
Apache Parquet
Apache Spark
Batch processing
CSV
Dashboard development
Data engineering
Data ingestion
Data lifecycle management
Data migration
Data pipelines
Data synchronization
Data transformation
Data visualization
JSON
Jupyter
LaTeX
MATLAB
Matplotlib
NumPy
Pandas
Plotly
Power BI
RabbitMQ
Reproducible analytics
Schema mirroring
Schema transformation
Schema validation
Seaborn
Telemetry ingestion
Telemetry pipelines
VarnishKafka
XML
Cloud and containers
Amazon EC2
Amazon ECS
Amazon Lightsail
Amazon RDS
Amazon S3
Amazon VPC
Amazon Web Services (AWS)
API Gateway
AWS APIs
AWS Lambda
Boto3
Cloud infrastructure
Cloud migration
Containers
Cost optimization
Docker
Docker Compose
EKS
Elastic Beanstalk
Elastic Load Balancing
Google Cloud Platform (GCP)
Google Cloud Storage
Google Cloud VPC
Google Compute Engine
Infrastructure cost analysis
Kubernetes
NRP Nautilus
Route 53
VirtualBox
WikiKube
Automation, delivery, and developer tools
API automation
Automated grading
AWS CLI
AWS CodeBuild
Build automation
CI/CD
Clang
clang-format
CLI automation
CLI development
CLion
Conda
Deployment automation
Deployment pipelines
DevOps
Eclipse
Environment configuration
flex
Git
Git submodules
GitHub
GitHub Actions
GitLab
GitLab CI/CD
Infrastructure as code
Infrastructure automation
Jenkins
Make
PyCharm
Release workflows
Self-service tooling
Sourcetree
Sublime Text
Terraform
Version control
Vim
Visual Studio
VS Code
Workflow automation
Xcode
YAML
Operating systems and concurrency
Buffered I/O
CentOS
Computer architecture
Concurrency
Condition variables
dlsym
Embedded operating systems
Endian-aware I/O
Fedora
FreeBSD
GNU Core Utilities
I/O redirection
Kali Linux
Linux
macOS
Memory management
MIPS
Multithreading
Mutexes
Mutual exclusion
N-Way blocking
Operating systems
Pipes (Shell piping)
POSIX
POSIX synchronization
POSIX threads
Priority scheduling
Process management
Raspberry Pi OS
Reader-writer locks
RISC-V
Scheduling
Starvation prevention
Synchronization
Systems programming
Token parsing
Ubuntu
Unix
Unix systems programming
Windows
Windows Server
Networking
Client-server protocols
HTTP
ICMP
Inter-subnet routing
Internet of Things (IoT)
IPv4
Linux networking
Load balancing
Mininet
Network byte order
Network programming
Network protocols
Network segmentation
Networking
Packet retransmission
POX
Recursive name resolution
Routing
Sliding-window protocols
Socket programming
Software-defined networking
TCP/IP
UDP
VPN
Wireshark
Security and access
Access control lists
Access management
ACM
Auth0
Authentication
AWS Identity and Access Management (AWS IAM)
AWS security groups
Cloud security controls
Computer security
Cryptography
Datawiza Access Broker
Firewall rules
Ghidra
Network security
Okta
Traffic filtering
Reliability and observability
Alerting
Amazon CloudWatch (AWS CloudWatch)
Failure detection
Fault injection
Grafana
Health checks
Incident investigation
Incident response
Incident triage
Log analysis
Logging
Metrics
Monitoring
NerdGraph API
New Relic
Observability
OpenTelemetry
Prometheus
Reliability engineering
Root cause analysis
Runbook development (Operational runbooks)
SLOs
Telemetry
Performance and debugging
blktrace
Bottleneck detection
Capacity analysis
Debugging
Diagnostics
fio
Flamegraphs
GDB
Infrastructure profiling
LD_PRELOAD
Linux /proc
perf
Performance analysis
Performance benchmarking
Performance debugging
Print debugging
Profiling
Reproducible benchmarking
Systems debugging
Valgrind
Web request trace analysis
Workload characterization
Workload trace analysis
AI and machine learning
Artificial intelligence
PyTorch
scikit-learn
TensorFlow
Research, simulation, and sustainability
Carbon analysis
Configuration search
Energy analysis
Energy modeling
Experimentation
gem5
Hardware configuration evaluation
Life cycle assessment
Parameter sweeps
Reproducible workflows
Research software engineering
SimpleSSD
Simulation (Simulation frameworks)
Sustainable computing
Total cost of ownership analysis
Workload replay
Collaboration and project delivery
Agile
Cross-functional collaboration
Jira
Programming assignment development
Project ownership (End-to-end project ownership)
Requirements gathering
Scrum
Teaching and mentorship
Technical documentation
Technical leadership
Technical training
Business systems and technical support
Bill-of-materials management
Canvas LMS
ConnectWise
Inventory tracking
Manufacturing workflow automation
Material requirements planning
Technical support
Workstation provisioning
Education
University of California, Santa Cruz
M.S. Computer Science (Sept. 2022 – Dec. 2024)
M.S. Computer Science (Sept. 2022 – Dec. 2024)
Coursework:
- Advanced Operating Systems
- Artificial Intelligence
- Algorithms
- Archival Storage System Design
- Computer Architecture
- Computer Security
- Cryptography
- Database Systems
- Distributed Systems
- Independent Study
- Programming Languages
University of California, Santa Cruz
B.S. Computer Science (Sept. 2018 – June 2022)
B.S. Computer Science (Sept. 2018 – June 2022)
Coursework:
- Artificial Intelligence
- Algorithms
- Assembly Language
- C Programming
- Compiler Design
- Computer Architecture
- Computational Models
- Computer Networks
- Computer Security
- Computer System Design
- Data Structures
- Database Design
- Distributed Systems
- Embedded Operating Systems
- Functional Programming
- Network Programming
- SQL
- Web Applications
- Honors: Dean’s List, Fall 2019, Winter 2020, and Spring 2020