Cecilia Sanjaya

Building CoachBridge for Peak Performance Unleashed — a production AI coaching platform serving real paying clients since January 2026. Architected in Next.js / TypeScript with Supabase (PostgreSQL + Auth), tier-based access control, usage metering, and LLM integration; Phase 2 targets advanced simulation and client analytics features.

Designed and verified a 3-stage pipelined RV32IM processor in Verilog, achieving 133.333 MHz timing closure (+0.299 ns WNS), a CPI of 1.168 on matrix multiply, and a CoreMark score of 318.6 — with Zephyr RTOS booting successfully on FPGA. Implemented MEM/WB→ID/EX forwarding, machine-mode CSR/interrupt support, and a shared multiplier optimization that improved Figure of Merit from 10.48 to 16.54 across 3,647 LUTs.

Fabricated functional NMOS transistors on silicon wafers through a complete IC process flow — thermal oxidation, ion implantation, UV photolithography, and wet/dry etching — in UC Berkeley's EE143 cleanroom. Characterized device electrical performance via I-V measurements and correlated results to process parameters, building hands-on intuition for how fabrication choices directly shape transistor behavior.

Modeled and characterized an NMOSFET across cutoff, triode, and saturation operating regions using SPICE simulation, extracting threshold voltage (Vt), transconductance (gm), and channel-length modulation (λ) from I-V curves. Analyzed short-channel effects and process variability, producing a validated compact model with formal design documentation — bridging device physics theory to real circuit design practice.

Designed and built a treble-boost guitar effects pedal from schematic to soldered PCB — selecting RC filter poles, biasing the transistor amplifier stage, and verifying the frequency response on a spectrum analyzer. Delivered a working circuit that measurably enhances high-frequency content and output amplitude, demonstrating complete analog design from component selection through physical build.

Designed a PCB smartwatch from schematic to layout in KiCad — integrating an ESP32 microcontroller, OLED display, accelerometer for step-count logic, and a Li-Po battery with a linear voltage regulator in a compact form factor. Programmed embedded firmware in C++ to display real-time clock and daily step count switchable via hardware button, demonstrating end-to-end hardware product development from PCB design through firmware debugging.

Built a voice-controlled robot car by designing the full analog signal chain — microphone biasing, anti-aliasing filter, and ADC interface — then implementing an SVD-based voice classification algorithm in C++ on an Arduino that reliably distinguishes spoken commands in real time. Integrated closed-loop PWM motor control to translate classified commands into directional movement, culminating in a live demo of the car navigating on voice input alone.

Built a single-pixel CT scanner using a photodiode circuit and motorized scanning rig, then reconstructed grayscale images of physical objects by applying back-projection and 2D Fourier transforms in Python — producing recognizable images from raw 1D scan data. Demonstrated how the linear systems framework maps directly to medical imaging principles used in CT and MRI reconstruction.

Designed and implemented an end-to-end encrypted file-sharing system in Go combining RSA-OAEP for identity and key wrapping, AES-CTR for content encryption, and HMAC-SHA256 for tamper detection — with full support for user registration, invitation trees, and revocation chains. Provided formal security arguments demonstrating resistance to a malicious dataserver with access to all stored ciphertext.

Performed hands-on exploitation of memory-unsafe C programs — constructing crafted inputs to trigger stack buffer overflows, overwrite saved return addresses, and hijack control flow — then analyzed how ASLR, stack canaries, and NX mitigations defeat each attack. Built the dual attacker-and-defender mental model needed to write and audit secure systems-level code.

Designed a pipelined RISC-V CPU from scratch — building a 32-bit ALU, register file, instruction decoder, and control unit, then wiring them into a complete datapath with correct branch and load hazard handling. Passed all provided ISA correctness tests, building foundational intuition for how processor microarchitecture directly implements the software-visible instruction set.

Built a terminal Snake game in C using a custom doubly-linked-list board representation and explicit heap allocation — exposing and fixing subtle memory corruption bugs through Valgrind and GDB. Hardened against all edge cases (wall collisions, self-intersections, invalid input) with a thorough unit test suite demonstrating production-quality C systems programming.

Optimized a neural network classifier in C by restructuring matrix multiplication for cache-friendly access patterns and applying SIMD intrinsics to vectorize the inner compute loop — achieving significant runtime reductions over the naive baseline. Preserved bit-exact correctness on all test inputs, demonstrating real-world performance engineering on hardware-constrained systems.

Built Controller Copilot with IBM SkillsBuild × watsonx.ai — an AI-powered financial analysis tool that detects 7 classes of transaction anomalies (duplicate payments, vendor spend spikes, round-number payments, weekend transactions, category mismatches, repeated amounts, and unusually large transactions) using deterministic rule-based detection. Paired each flagged item with AI-generated explanations via IBM's Granite model and a natural-language query interface, replacing manual spreadsheet audit with an interactive, sortable workspace.

Implemented BFS, DFS, UCS, and A* graph search in Python and designed admissible, consistent heuristics that dramatically reduced node expansions required to solve Pacman maze configurations. Analyzed completeness and optimality guarantees for each algorithm, demonstrating that A* with a domain-specific heuristic finds optimal solutions with a fraction of the nodes explored by uninformed search.

Built minimax agents with alpha-beta pruning and expectimax agents for adversarial multi-ghost Pacman — designing evaluation functions that balance food collection, ghost avoidance, and positional advantage under strict depth limits. Demonstrated that principled adversarial planning with pruning achieves significantly higher win rates than reflex-based baselines while staying within the compute budget.

Solved MDP planning and model-free control tasks using value iteration and Q-learning — tuning discount factors, learning rates, and epsilon schedules to converge on near-optimal policies across grid-world environments. Showed that Q-learning agents trained on one layout generalized reliably to held-out configurations, achieving close-to-optimal cumulative reward without any environment model.

Implemented exact and approximate Bayesian inference for hidden ghost tracking — maintaining belief distributions over all grid positions and updating them from noisy sensor readings using Bayes' rule and HMM forward algorithms. Compared particle-filter approximate inference to exact variable elimination, demonstrating near-identical tracking accuracy at a fraction of the compute cost.

Implemented Naive Bayes and Perceptron classifiers from scratch and applied them to digit and face image classification — engineering spatial features and tuning hyperparameters via cross-validation to maximize accuracy on held-out test sets. Analyzed precision-recall trade-offs and classifier stability to determine which model best suits each data distribution.

Built a fully playable 2D tile-based world game in Java — implementing procedural terrain generation with BSP-tree partitioning, keyboard-driven player interaction, and persistent save/load via Java serialization. Architected with clean model-view separation across multiple collaborating classes, demonstrating object-oriented design and algorithmic thinking at full project scale.

Designed and shipped a full iOS study-partner matching app in Swift — implementing user profile creation, preference-based card-swipe matching, and a Figma-designed UI — within a 6-week sprint as part of Berkeley's Cubstart program. Built UIKit navigation, swipe-state management, and a UX pattern that mirrors industry-standard matching apps, resulting in a polished demo-ready product.

Implemented the complete game logic for 2048 in Java — tile-merging rules, directional sliding, scoring, and win/lose detection — with a clean model separated from the provided GUI rendering layer. Validated all corner cases including full board fills, simultaneous merges, and score edge cases with a deterministic unit test suite.

Implemented a generic double-ended queue backed by a circular doubly-linked list with sentinel nodes in Java, supporting amortized O(1) front/back operations. Validated correctness and edge cases — empty deque, single-element, and alternating add/remove sequences — with a comprehensive JUnit test suite.

Implemented a generic deque backed by a circular resizing array in Java, achieving amortized O(1) operations through geometric doubling on expansion and halving on shrinkage to maintain ≥25% utilization. Minimized unnecessary copying during resizes and validated memory efficiency and correctness across hundreds of mixed-operation test sequences.

Built a word-frequency exploration tool over the Google Ngram corpus in Java — indexing millions of word-year-frequency records into a custom hash-map structure paired with a WordNet synonym graph for hyponym-aware queries. Answered arbitrary time-bounded frequency and hyponym queries efficiently by pre-computing the right index structure at load time.

Built a complete dice-game engine in Python — implementing turn logic, four special scoring rules, and a strategy optimizer that simulates thousands of games to find the highest expected-value dice count for any score state. Used higher-order functions and functional composition to cleanly separate game rules from strategy evaluation logic.

Built a typing-speed assistant in Python that measures WPM and accuracy for arbitrary prompts, then applies a minimum-edit-distance autocorrect function to correct typos against a vocabulary list. Implemented multi-player performance tracking and a custom recursive edit-distance algorithm, demonstrating functional programming patterns and string algorithm design.

Developed a tower-defense simulation in Python using deep class hierarchies — 10+ specialized Ant and Bee subclasses with unique behaviors, damage models, and resource constraints — demonstrating OOP principles including inheritance, polymorphism, and composition. Implemented a complete game loop with placement validation, turn resolution, and win/loss state management.

Implemented a Scheme interpreter in Python supporting nested expressions, first-class functions, lexical scoping with environment frames, tail-call optimization, and a complete set of special forms (define, lambda, if, cond, let, quasiquote). Built the tokenizer, parser, and evaluator from scratch, culminating in a REPL that correctly evaluates complex recursive and higher-order programs.

Launched StackXo, a web design studio, and delivered 2 client websites — handling the full lifecycle from discovery through deployment on custom domains, generating real client revenue. Each site is fully responsive, optimized for Core Web Vitals, and tailored to the client's brand and conversion goals.

Designed and developed a personal portfolio website for a client — translating brand requirements into a responsive, polished web presence with smooth interactions and custom typography. Delivered from brief to live site on a custom domain within a 2-week timeline.

Built the business website for Peak Performance Unleashed from scratch — a performance coaching site designed for credibility and conversion — resulting in the client later hiring me as a Software Engineer to build their core AI platform, CoachBridge. Fully responsive with performance-optimized assets and a clear service-to-CTA information hierarchy.