113 projects across five schools - Artificial Intelligence (53), Autonomous Systems (20), Business (20), Data Science (14), and Programming and Software Development (6) - spanning 37 Nanodegree programs, 2017 to 2026. Work covers control and state estimation, perception and sensor fusion, deep and reinforcement learning, agentic systems and retrieval, AI governance and responsible deployment, data architecture and governance, analytics and business intelligence, and AI product, growth, and marketing strategy.
Eight projects chosen for the scope of their decision-making and technical delivery:
- Real-Time Fraud Detection Architecture - event-driven platform designed for 1,000 transactions per second with a p99 decision budget under 250 ms; states its delivery-semantics, replay isolation, and cost trade-offs explicitly.
- Cleared for Launch: AI Governance Assessment - EU launch readiness review of a healthcare clinical decision-support system across regulatory classification, risk management, vendor governance, monitoring, and executive reporting, against the EU AI Act and NIST AI RMF.
- Ethical Multi-Agent Data Orchestrator - source-isolated structured, unstructured, and multimodal agents with inline fairness, privacy, and image-safety controls, deployed across an Azure data and content-safety stack.
- Orphan Finder - rare-disease variant-to-therapy pipeline over ClinVar, PubMed, and ClinicalTrials.gov; three agents (+1 orchestrator), with a per-call audit trace and seed-level determinism.
- Medical Data Processing Enterprise Data Lake - layered ingestion, processing, and serving design replacing a single-node system handling roughly 77,000 daily files across 8,000 facilities.
- Home Service Robot - full autonomy stack in ROS and Gazebo: SLAM mapping, AMCL localization, navigation-stack planning, and a task state machine driving pick-and-deliver behavior end to end.
- Unscented Kalman Filter - nonlinear state estimation over fused lidar and radar under a CTRV motion model, in C++ with Eigen.
- Enterprise Multi-Agent Review - production-shaped Claude Agent SDK reviewer that dispatches three specialists across a pull request, validates structured findings, recomputes model-generated summaries, and persists reports only after successful, rate-limited completion.
Deep learning, reinforcement and multi-agent RL, computer vision, NLP and speech, generative AI and fine-tuning, RAG and agent orchestration, AI governance and responsible deployment, control and state estimation, sensor fusion, SLAM, localization and motion planning, ROS and robotics, cyber-physical and embedded systems, SQL and data modeling, ETL and data lake architecture, data governance and MDM, statistics and experiment design, business intelligence and DAX, software architecture and test-driven development, VR with Unity, product and project management, growth and financial modeling, marketing analytics.
Mostly implemented in C++, Python/Jupyter, MATLAB, C#, JavaScript, SQL, DAX, and MicroPython.
Jump to:
- School of Artificial Intelligence
- School of Autonomous Systems
- School of Data Science
- School of Business
- School of Programming and Software Development
Projects are grouped by Udacity School, with more recent completions toward the top. Program successions are interleaved where newer content replaced older material - Machine Learning with PyTorch supersedes the original Machine Learning Nanodegree, for example - so entry dates vary within sections. The 2017-2020 work is retained deliberately: the progression in software practice across the span is part of what the index records.
The recent programs sit within an MSc in Artificial Intelligence and an MBA in AI Product Management at the Udacity Institute of AI and Technology. The earlier programs were standalone Nanodegrees completed years before those degrees began (many became electives).
P1. Harness Engineering
High-level goal: engineer reliable Claude agent harnesses through tool-use loops, long-conversation context management, tiered state, crash recovery, and Claude Code configuration.
Technologies used: Claude API, Claude Code, Python, Pydantic, SQLite, agent orchestration, context engineering, pytest.
P2. Agentic Analyst
High-level goal: build an MCP-powered competitor analyst that scrapes LLM-inference pricing, stores structured plans, and answers follow-up comparison questions from retained data.
Technologies used: Python, Model Context Protocol, Firecrawl, Anthropic API, SQLite, uv, agentic workflows.
P3. Evaluation and Observability
High-level goal: make AI extraction and multi-source investigation pipelines trustworthy through schema validation, retry and routing controls, independent review, calibration, and resilient evidence synthesis.
Technologies used: Python, Pydantic, JSON Schema, pytest, mypy, Ruff, model evaluation, observability, human-in-the-loop routing.
P4. Enterprise Multi-Agent Review
High-level goal: orchestrate specialized Claude subagents to review pull requests, validate findings, and produce a resilient structured report with rate limiting and retries.
Technologies used: Claude Agent SDK, TypeScript, Model Context Protocol, Zod, Vitest, Winston, GitHub API, multi-agent systems.
P1. Finance Manager for Freelancers
High-level goal: track freelancer income and expenses through a maintainable Python application that applies classic object-oriented design patterns.
Technologies used: Python, Singleton, Adapter, Observer, Command patterns, unit testing.
P2. Fraud Detection Architecture
High-level goal: design a scalable, replayable, and observable event-driven fraud-detection platform for financial services.
Technologies used: cloud-native architecture, event-driven design, fraud detection, observability, resilience, Mermaid diagrams.
P3. Order Management System
High-level goal: deliver a test-driven order-tracking service with a Flask API and web frontend.
Technologies used: Python, Flask, REST APIs, test-driven development, pytest, web frontend.
P4. Flashcard Quizzer
High-level goal: create an AI-assisted Python CLI for structured study with sequential, random, and adaptive quiz modes.
Technologies used: Python, AI-assisted development, CLI design, adaptive learning modes, testing.
P1. EcoHome Energy Advisor
High-level goal: provide RAG + tool-using guidance for smart-home energy optimization using an agentic workflow.
Technologies used: LangChain, LangGraph, Python, notebooks for DB/RAG setup and evaluation, tool-backed agent.
P2. DocDacity - Document Assistant
High-level goal: route user intents to QA, summarization, or calculator agents for document question answering and reporting.
Technologies used: LangChain, intent classification and routing, calculator tool, document search/read/stats, session memory and logging.
P3. UDA-Hub - Multi-Agent Support System
High-level goal: triage support tickets with a LangGraph multi-agent system that uses tools, sentiment, and knowledge base lookups.
Technologies used: LangGraph multi-agent graph, FastMCP tools over SQLite, sentiment-aware routing, KB with ~14 articles, REPL demo and tests.
P1. Ethical Audit Plan: Gender Bias in a Fine-Tuned Language Model
High-level goal: audit an intentionally gender-biased fine-tuned language model through controlled prompts, counterfactual comparisons, and explainability signals; document findings and propose mitigation controls.
Technologies used: Python, PyTorch, Hugging Face Transformers and Datasets, pandas, NumPy, Jupyter, Jaccard similarity, Model Cards, Responsible AI risk assessment.
P2. Cleared for Launch: AI Governance Assessment
High-level goal: assess whether a healthcare generative AI clinical decision-support system is ready for EU launch across regulatory classification, risk management, vendor governance, model performance, monitoring, and executive readiness.
Technologies used: Python, pandas, NumPy, Matplotlib, Seaborn, Jupyter, openpyxl, EU AI Act, NIST AI RMF, Model Cards, vendor governance, governance dashboards.
P3. Ethical Multi-Agent Data Orchestrator
High-level goal: route neighborhood questions to source-isolated structured, unstructured, and multimodal agents while applying inline fairness, privacy, and image-safety safeguards.
Technologies used: Azure Key Vault, Azure OpenAI GPT-4.1-mini, Azure PostgreSQL, Cosmos DB for MongoDB, Azure Blob Storage, Azure AI Content Safety, LangChain, LangGraph, ChromaDB, Fairlearn, Presidio, Hugging Face CLIP.
P1. Multi-Agent Orchestrator Logistics System
High-level goal: coordinate up to five agents to automate inventory, quoting, and fulfillment flows for a paper company.
Technologies used: Python, Pydantic AI multi-agent graph, SQLite or SQLAlchemy-backed tools, structured outputs, OpenAI proxy integration.
Scope: uses a compact graph of cooperating agents with shared tools and structured I/O, suited for quote-to-cash style flows.
P2. AI-Powered Genetic Workflow for Product Management
High-level goal: run persona-aware analysis, routing, and staged evaluation to generate and score product requirements.
Technologies used: Python, OpenAI-compatible APIs, RAG over CSV knowledge stores, modular agent harness.
Scope: orchestrates multi-step evaluation and reporting for PM artifacts with traceable intermediate products.
P3. AI Research Agent - Video Game Industry
High-level goal: answer executive queries on market structure using RAG over structured game data and vector embeddings.
Technologies used: Python, ChromaDB with SQLite, retrieval and summarization agents, notebook-driven workflows.
Scope: retrieval pipeline with lightweight vector store for exploratory industry analysis.
P4. Multi-Agent Travel Assistant System
High-level goal: prototype a travel concierge that plans itineraries, evaluates booking options, and coordinates customer messaging across specialized agents.
Technologies used: Python, framework-agnostic multi-agent orchestration patterns, OpenAI-compatible models.
Scope: modular assistants for planning, evaluation, and communications across a shared state.
P1. Orphan Finder: Rare Disease Variant-to-Therapy Matchmaker
High-level goal: rank candidate variants with ClinVar, synthesize PMID-backed evidence from PubMed, and match to ClinicalTrials.gov trials to produce a clinician-style, auditable brief.
Technologies used: Python 3.10, three-agent (+1) orchestration (Orchestrator, VariantPrioritizer, EvidenceSynthesizer, TrialMatcher), ClinVar queries, PubMed E-utilities, ClinicalTrials.gov API, JSONL run logging.
Scope: integrates three public biomedical sources with an auditable JSONL trace of tool calls and selections, producing a report.md and ranked_variants.csv per run for reproducibility.
P1. UdaciScan - An AI Research Agent for Drug-Repurposing Insights
High-level goal: answer drug repurposing questions by retrieving PubMed abstracts, gating on retrieval confidence, extracting and ranking candidate drugs, and emitting reproducible briefs with traces.
Technologies used: Python 3.10+, ChromaDB vector store, OpenAI-compatible endpoint via Vocareum, PubMed and NCBI integrations, YAML configuration, CLI runner with JSON/Markdown outputs.
Scope: end-to-end CLI and notebook workflows with vector search, ranked outputs, and artifact logging.
P1. AI Photo Editing & Inpainting
High-level goal: build an interactive app for targeted inpainting and style edits on user-uploaded photos.
Technologies used: Python, Streamlit, diffusers or Stable Diffusion inpainting, Pillow, OpenCV.
P2. Custom Architecture Framework Chatbot
High-level goal: create an LLM assistant that answers questions about a proprietary architecture governance framework using RAG.
Technologies used: LangChain, OpenAI via Vocareum, ChromaDB or FAISS, pandas, Python notebooks and CLI.
Scope: RAG pipeline with configurable ingestion and vector store, designed for governance corpus Q&A and reproducible CLI runs.
P3. Lightweight Fine-Tuning of a Foundational Model
High-level goal: fine-tune DistilBERT for sentiment classification with parameter-efficient techniques.
Technologies used: Hugging Face Transformers, PEFT/LoRA, PyTorch, datasets, scikit-learn metrics.
P4. HomeMatch - Personalized Real Estate Agent
High-level goal: generate synthetic listings, store text and image embeddings, collect buyer preferences, and return GPT-personalized property narratives.
Technologies used: LangChain, LangChain-OpenAI, ChromaDB, CLIP and Sentence Transformers, Pillow, pandas.
P1. Navigation
High-level goal: train an agent to collect target items and avoid distractors in a Unity environment to maximize cumulative reward.
Technologies used: PyTorch, DQN/Double DQN with experience replay and target networks, Unity ML-Agents environment.
P2. Continuous Control
High-level goal: learn a continuous control policy to keep a robotic arm’s end-effector at target positions in the Reacher environment.
Technologies used: PyTorch, actor-critic (DDPG/TD3), Ornstein-Uhlenbeck noise, Unity ML-Agents environment.
P3. Collaboration and Competition
High-level goal: train two cooperative agents to sustain rallies in a shared tennis-like environment under multi-agent dynamics.
Technologies used: PyTorch, multi-agent DDPG or MADDPG variants, parameter noise/exploration strategies, Unity multi-agent environment.
P1. GAN Face Generator
High-level goal: synthesize realistic human faces from random latent vectors by training a GAN on CelebA.
Technologies used: PyTorch, torchvision, DCGAN/WGAN-GP training loop with gradient penalty, NumPy, Matplotlib, Jupyter.
P2. Landmark Classification & Social Media Tagging
High-level goal: identify which of 50 global landmarks appears in a user photo to enable automatic social-media tagging.
Technologies used: PyTorch CNNs, transfer learning with pretrained backbones, PIL, numpy/pandas, Matplotlib/Seaborn, helper training utilities.
P3. MNIST Handwritten Digit Classifier
High-level goal: reach greater than 98 percent accuracy on MNIST with a compact MLP and documented training pipeline.
Technologies used: PyTorch, torchvision datasets, BatchNorm and dropout, AdamW with LR scheduling, Jupyter.
P4. Text Translation & Sentiment Analysis with Transformers
High-level goal: translate multilingual movie reviews to English and attach sentiment labels to produce a unified analytics-ready CSV.
Technologies used: Hugging Face Transformers, MarianMT translation, DistilBERT sentiment pipeline, pandas, PyTorch, sacremoses.
P1. Facial Keypoint Detection
High-level goal: localize facial landmarks to support downstream tasks such as tracking, pose estimation, or expression analysis.
Technologies used: PyTorch CNNs, data augmentation, MSE loss, OpenCV-based visualization.
P2. Image Captioning
High-level goal: generate natural language descriptions from images using an encoder-decoder architecture.
Technologies used: CNN encoder (e.g., ResNet) with RNN/LSTM decoder, PyTorch, beam search or greedy decoding.
P3. Landmark Detection & Robot Tracking
High-level goal: detect landmarks and estimate robot pose in a mapping task using probabilistic state estimation.
Technologies used: EKF-SLAM or particle filtering, NumPy, OpenCV, Python visualization.
P1. HMM Part-of-Speech Tagger
High-level goal: train a hidden Markov model POS tagger over the universal tagset and decode sequences on held-out text.
Technologies used: Python, Pomegranate, NumPy, Jupyter (GraphViz optional for graph rendering).
P2. Machine Translation
High-level goal: translate sentences from English to French with a sequence-to-sequence neural model.
Technologies used: PyTorch, RNN/LSTM/GRU encoder-decoder with attention, tokenization, batching.
P3. DNN Speech Recognizer
High-level goal: build an end-to-end speech recognizer that maps raw audio to text using deep neural networks with CTC decoding.
Technologies used: Python, TensorFlow/Keras, NumPy, SoundFile, Jupyter.
P1. Backtest a Dynamic Investment Strategy
High-level goal: implement and evaluate a rule-based strategy with historical data to compute risk/return characteristics.
Technologies used: Jupyter Notebook, pandas, NumPy, rolling metrics, basic backtesting utilities and plotting.
P2. Data Transformation for Trading Models
High-level goal: prepare market time series for modeling by cleaning, aligning, and deriving predictive features.
Technologies used: pandas, feature engineering, normalization, windowed aggregations, technical indicators.
P1. Finding Donors
High-level goal: predict potential charitable donors from census-like attributes to optimize outreach.
Technologies used: scikit-learn (SVM, RandomForest, GradientBoosting), pandas, feature scaling, cross-validation.
P2. Create Your Own Image Classifier
High-level goal: implement transfer learning for image recognition with configurable hyperparameters and saved checkpoints.
Technologies used: PyTorch, torchvision models, command-line training and inference utilities.
P3. Identifying Customer Segments
High-level goal: discover latent customer groups to support targeted marketing and product decisions.
Technologies used: PCA for dimensionality reduction, KMeans clustering, scikit-learn, pandas.
P1. Predicting Boston Housing Prices
High-level goal: model median home value as a function of neighborhood features and evaluate generalization.
Technologies used: scikit-learn regressors, grid search, learning curves, cross-validation.
P2. Finding Donors
High-level goal: rank prospective donors to improve campaign efficiency and ROI.
Technologies used: scikit-learn classifiers, feature engineering, model selection and evaluation metrics.
P3. Titanic Survival Exploration
High-level goal: predict passenger survival to illustrate supervised learning pipelines and error analysis.
Technologies used: decision trees, ensemble baselines, scikit-learn, pandas.
P4. Smart Cab
High-level goal: learn a driving policy that obeys rules and reaches destinations in a simulated city.
Technologies used: Q-learning, epsilon-greedy exploration, Python simulation.
P5. Customer Segments
High-level goal: segment customers to enable differentiated strategies for retention and growth.
Technologies used: PCA, clustering (KMeans), scikit-learn, pandas.
P6. Dog Breed Classifier
High-level goal: detect whether an image contains a dog or human and classify the dog breed.
Technologies used: CNN transfer learning (e.g., VGG, ResNet), PyTorch, data augmentation.
P7. Plagiarism Detection
High-level goal: identify potential plagiarism by measuring document similarity against known sources.
Technologies used: engineered text similarity features, SVM or Logistic Regression, scikit-learn.
P8. Capstone: Deep Traffic (MIT)
High-level goal: learn a high-throughput driving policy in a browser-based multi-lane traffic simulator.
Technologies used: deep reinforcement learning policy networks in JavaScript, simulator-provided APIs, hyperparameter search.
P1. GitHub Copilot Starter
High-level goal: refactor a simple Sudoku game to a modern React and Next.js web app, adding generator, timer, hints, difficulty selection, validation, and persistence of top scores.
Technologies used: JavaScript, React, Next.js, HTML, CSS, optional Tailwind or modular CSS, localStorage for leaderboard.
P1. Image Classification for a City Dog Show
High-level goal: classify images of dogs and humans and identify dog breeds using a pre-trained convolutional neural network.
Technologies used: Python, PyTorch, torchvision, NumPy, PIL, transfer learning.
P2. Create Your Own Image Classifier
High-level goal: build and train a flower classifier and expose a command-line interface for training and inference.
Technologies used: PyTorch, torchvision, argparse, PIL, checkpointing for transfer learning.
P1. LiDAR Obstacle Detection
High-level goal: separate ground from obstacles and cluster objects in 3D point clouds.
Technologies used: C++, PCL, RANSAC plane fitting, KD-Tree Euclidean clustering.
P2. 2D Object Tracking
High-level goal: detect and track keypoints across frames to measure motion and build correspondences.
Technologies used: C++, OpenCV (detectors/descriptors), descriptor matching.
P3. 3D Object Tracking
High-level goal: associate camera detections with lidar points and track objects over time.
Technologies used: C++, OpenCV, PCL, bounding box association, time-to-collision estimation.
P4. Radar Target Generation and Detection
High-level goal: simulate FMCW radar signals and implement CFAR to detect targets.
Technologies used: MATLAB/Octave signal processing, CFAR, range-Doppler maps.
P5. Unscented Kalman Filter
High-level goal: estimate object state under nonlinear dynamics using UKF on lidar and radar measurements.
Technologies used: C++, Eigen, CTRV process model, sigma-point filtering.
P1. Backyard Flyer
High-level goal: plan and execute a simple waypoint mission to validate control and state estimation.
Technologies used: Python, drone simulator APIs, waypoint planning.
P2. 3D Motion Planner
High-level goal: compute collision-free global paths in a mapped environment.
Technologies used: Python, occupancy grids, A* search, heuristic tuning.
P3. Building a Controller
High-level goal: design attitude and position controllers for a quadrotor to track trajectories.
Technologies used: C++ or Python control loops, PID/linear controllers, simulator integration.
P4. Building an Estimator
High-level goal: estimate vehicle state from noisy IMU and GPS using probabilistic filtering.
Technologies used: C++ Extended Kalman Filter, sensor fusion, tuning and validation.
P1. Autonomous Search Rover
High-level goal: perceive obstacles and navigable terrain to autonomously explore and retrieve samples.
Technologies used: Python, OpenCV perception pipeline, decision logic, telemetry logging.
P2. Kinematics (Kuka-KR210)
High-level goal: compute forward and inverse kinematics for a 6-DOF manipulator and validate poses.
Technologies used: Python, ROS, DH parameterization, SymPy for IK.
P3. 3D Perception (PR2)
High-level goal: segment scenes and recognize tabletop objects for pick-and-place tasks.
Technologies used: ROS, PCL (voxel grid, RANSAC), clustering, SVM or template matching.
P4. Follow Me
High-level goal: detect and follow a target person in video streams.
Technologies used: semantic segmentation or object detection CNNs, ROS nodes for perception and control.
P5. Robotic Inference
High-level goal: apply deep learning inference for robotic perception or manipulation tasks.
Technologies used: TensorFlow or PyTorch models, ROS integration, inference optimization.
P6. Where am I?
High-level goal: localize a robot within a known map using probabilistic techniques.
Technologies used: ROS AMCL or particle filter localization, sensor models, map server.
P7. Map My World
High-level goal: build a map while estimating pose from onboard sensors.
Technologies used: ROS with RTAB-Map or SLAM backends, bagging and visualization tools.
P8. Deep Reinforcement Learning Arm (Kuka KR-210)
High-level goal: learn a control policy for a manipulator to reach or grasp under uncertainty.
Technologies used: PyTorch RL algorithms, robotics simulator interfaces, reward shaping.
P9. Home Service Robot
High-level goal: perform autonomous pick-and-deliver tasks in a house map.
Technologies used: ROS Navigation stack (mapping, localization, planning), Gazebo, custom state machine.
P1. Communication Embedded Systems
High-level goal: simulate three embedded nodes exchanging data across LIN, CAN, I2C, and SPI with separate modules.
Technologies used: C++ and CMake builds, ISR loops and port separation, Linux builds for sensor monitor, battery module, and data logger.
P2. Embedded Input Reader (Raspberry Pi Pico W)
High-level goal: implement a muxed switch reader with button passcode logic and LED control, runnable in Wokwi.
Technologies used: MicroPython, Wokwi simulator (diagram.json, wokwi.toml), debounce logic, GPIO handling and LED toggling.
P1. Design an HR Database
High-level goal: elicit business requirements and design a normalized relational schema for HR operations.
Technologies used: ER modeling, PostgreSQL 9.5 DDL, access control and backup considerations.
P2. Design a Data Warehouse
High-level goal: model analytical workloads with star schemas and implement an end-to-end ETL pipeline.
Technologies used: dimensional modeling, PostgreSQL, SQL-based ETL, performance tuning.
P3. Medical Data Processing Enterprise Data Lake
High-level goal: design an open-source enterprise data lake to replace a single-node SQL Server system processing ~77K daily files across ~8K medical facilities, with layered ingestion, processing, and serving.
Technologies used: Apache NiFi, Kafka, HDFS/HBase, Spark, Flink, Hive, Presto, Druid, Superset, Ranger/Knox/Kerberos, Mermaid diagrams and design docs.
P4. SneakerPark Data Governance
High-level goal: establish Phase 1 enterprise data management, including a critical data catalog, data quality profiling, and an MDM design spanning multiple microservices.
Technologies used: PostgreSQL, SQL, Mermaid for ERDs and architecture, HTML/CSS dashboard mockups, Excel/CSV templates.
P1. Investigate a Dataset
High-level goal: explore and analyze a firearm and census dataset, articulate key questions, and document visual findings.
Technologies used: Jupyter Notebook, pandas, NumPy, Matplotlib, exploratory data analysis workflow.
P2. Cybersecurity Data Wrangling
High-level goal: gather, assess, clean, and analyze Kaggle Cyber Security Attacks and MITRE ATT&CK datasets, including an optional graph export.
Technologies used: pandas, NumPy, programmatic data collection, data quality and tidiness fixes, NetworkX for graph representation, GraphQL.
P3. Communicate Nuclear IAEA Data Findings
High-level goal: produce exploratory and explanatory visualizations on nuclear infrastructure and electricity statistics using merged country-level data.
Technologies used: Jupyter Notebook, pandas, Matplotlib, HTML exports for presentation-ready deliverables.
P1. Salary Prediction via Linear Regression
High-level goal: build, fit, and interpret a salary prediction model using linear regression with clear diagnostics and interpretation.
Technologies used: Python, pandas, NumPy, statsmodels or scikit-learn linear models, Matplotlib, Jupyter.
P2. A/B Test Results Analysis
High-level goal: evaluate an online experiment for conversion differences using hypothesis tests and effect size.
Technologies used: pandas, SciPy statistical tests, confidence intervals, Matplotlib, Jupyter.
P3. Basketball Scoring Probabilities
High-level goal: model and compute scoring probabilities for game scenarios with worked, notebook-based examples.
Technologies used: probability rules, combinatorics, NumPy, pandas, Jupyter.
P4. Health and Sleep Quality Description
High-level goal: explore and describe health and sleep quality data to surface descriptive insights and visual patterns.
Technologies used: pandas, descriptive statistics, Matplotlib or Seaborn visualization, Jupyter.
P1. Deforestation Exploration
High-level goal: explore deforestation datasets with relational queries to surface trends and comparisons.
Technologies used: SQL querying, joins and aggregations, result interpretation and basic visualization exports.
P2. Social News Aggregator (Udiddit) - Schema Redesign and Migration
High-level goal: normalize a flawed forum database, migrate existing data, and validate integrity at scale.
Technologies used: PostgreSQL DDL/DML/DQL, indexes and constraints, Dockerized Postgres 15 workflow, validation queries and expected counts.
P1. Flight Delays and Cancellations
High-level goal: analyze air travel performance and factors driving delays and cancellations.
Technologies used: SQL queries, relational joins and aggregations, data visualization.
P1. Agentic Expense Reporting System
High-level goal: automate receipt parsing, policy checks, and payment decisions through a multi-agent workflow.
Technologies used: OCR and data extraction, spreadsheet APIs, rule evaluation, payment service integration.
P1. Delivering an ML/AI Strategy
High-level goal: define a practical ML/AI strategy aligned with product and organizational constraints.
Technologies used: strategic planning artifacts, data maturity assessment, roadmap and KPI definition.
P1. Create a Medical Image Data Annotation Job
High-level goal: specify a labeling task with clear guidelines to ensure high-quality medical image annotations.
Technologies used: labeling tool configuration, JSON schemas, quality control workflows.
P2. Build a Model with Google AutoML
High-level goal: train and evaluate a classification model using a managed AutoML service.
Technologies used: Google Cloud AutoML, dataset curation, evaluation metrics and model export.
P3. Capstone: AI for Space
High-level goal: propose an AI product concept for space applications with problem framing and feasibility.
Technologies used: product requirement definition, risk and stakeholder analysis, experimental roadmap.
P1. Craft Snacks: Growth Loop Initiative
High-level goal: design and validate a referral-driven growth loop for a snack-subscription service, from customer insight through experimentation.
Technologies used: AARRR funnel analysis, growth-loop design, personas, A/B testing, viral-coefficient measurement, Ansoff Matrix.
P2. Let It Grow: Activation and Retention Analysis
High-level goal: identify onboarding friction, activation behaviors, cohort retention patterns, and experiments to reduce churn.
Technologies used: activation funnels, ICE prioritization, cohort and segment analysis, lifecycle modeling, churn and LTV analysis, spreadsheets.
P3. Priceless Penny: Growth and Financial Model
High-level goal: develop a growth strategy and financial model that translates acquisition, retention, and monetization assumptions into measurable outcomes.
Technologies used: financial modeling, unit economics, KPI trees, cohort analysis, growth forecasting, Excel, PowerPoint.
P1. Flyber MVP Launch Strategy
High-level goal: use comparable New York City taxi data and user research to identify customer problems, test launch hypotheses, and propose an evidence-based MVP strategy for a flying-taxi service.
Technologies used: product discovery, market analysis, SQL, Python, Tableau, spatial analysis, temporal analysis, user research, MVP strategy.
P2. Iterative Design and the Future of Flyber
High-level goal: evaluate a multivariate experiment, diagnose funnel and cohort underperformance, synthesize qualitative rider evidence, and design the next statistically valid product test.
Technologies used: product analytics, KPI design, multivariate testing, Welch t-tests, Holm adjustment, funnel analysis, cohort analysis, qualitative research, Tableau.
P3. Flyber Scalable Data Strategy
High-level goal: define the stakeholders, data model, ETL controls, growth analysis, and cloud warehouse strategy required to scale Flyber's rider-event data platform.
Technologies used: data strategy, stakeholder analysis, relational data modeling, ETL, data-quality reconciliation, Python, Excel, Matplotlib, BigQuery.
P2. Design Sprint
High-level goal: validate a product idea through a structured multi-day sprint workflow.
Technologies used: sprint artifacts, user journey mapping, prototyping and feedback capture.
P1. Crafting an Analytics Brief
High-level goal: build a strategic analytics brief for Boston Dynamics Spot Enterprise with a 14-slide HTML deck and funnel visualization.
Technologies used: Python, Matplotlib, HTML presentation export.
P2. Sales Objective Analysis
High-level goal: compare Black Friday 2017 vs 2018 across objectives, audience, marketing, sales, and products, producing a structured analysis report and charts.
Technologies used: pandas, openpyxl, matplotlib, seaborn, numpy.
P3. Visual Storytelling with Data
High-level goal: explain seasonal gift-shopping behavior using minimalist visuals and an HTML narrative for UK ecommerce.
Technologies used: pandas, matplotlib, numpy, HTML story output.
P2. Facebook Campaign
High-level goal: plan, launch, and analyze a paid social campaign against business objectives.
Technologies used: Facebook Ads Manager, audience targeting, KPI tracking and reporting.
P5. Udacity Enterprise Portfolio
High-level goal: present a cohesive digital marketing portfolio for enterprise stakeholders.
Technologies used: portfolio structuring, analytics summaries, content curation.
P1. Out-of-the-Box Analytics
High-level goal: optimize job-advertising spend by evaluating vendor efficiency, category performance, and daily pacing.
Technologies used: Power BI, Power Query, DAX KPI measures, advertising-spend analysis, executive dashboards.
P2. US Economy, Population & Employment Model
High-level goal: analyze long-run US population, employment, unemployment, earnings, and time-use trends through a multi-source data model.
Technologies used: Power BI, Power Query, star-schema modeling, DAX, Census Bureau data, Bureau of Labor Statistics data, Azure Blob Storage.
P3. Commercial Flight Analysis
High-level goal: improve New York flight operations through delay, passenger-satisfaction, airport-clustering, forecasting, anomaly, and delay-risk analysis.
Technologies used: Power BI, DAX regression, what-if analysis, automatic clustering, forecasting, anomaly detection, Key Influencers, predictive-risk reporting.
P1. CDC Outbreak Response MVP Plan
High-level goal: prioritize a minimum viable CDC outbreak-response platform that enables timely case reporting, regional visibility, testing and test-kit tracking, and evidence-based allocation decisions.
Technologies used: Agile product visioning, product roadmaps, release planning, user stories, acceptance criteria, MVP prioritization, Microsoft Excel, Microsoft Word.
P2. WorldVisitz Mobile Application Agile Delivery Launch
High-level goal: make the executive case for Agile and onboard a distributed travel-product team to a Scrum-based delivery model supported by XP engineering practices.
Technologies used: Agile Manifesto, Scrum, Kanban, Extreme Programming, information radiators, sprint ceremonies, Definition of Done, Shu Ha Ri coaching, Microsoft PowerPoint.
P3. The A-Team Agile Communication Project
High-level goal: track and communicate six sprints of a software-commerce MVP through backlog evolution, burn-down and burn-up reporting, committed-versus-delivered analysis, and a management BVIR.
Technologies used: Scrum, sprint planning, story-point estimation, burn-down charts, burn-up charts, committed-versus-delivered reporting, management dashboards, Python, Matplotlib, Microsoft PowerPoint, Microsoft Excel.
P1. Carnival
High-level goal: build interactive VR mini-games to demonstrate physics and interaction design.
Technologies used: Unity, C#, VR interaction frameworks.
P2. Design an Apartment
High-level goal: create a navigable VR interior scene with lighting and materials suitable for presence.
Technologies used: Unity, C#, scene layout and optimization.
P3. Maze
High-level goal: implement a VR maze experience with locomotion and collision handling.
Technologies used: Unity, C#, VR controller input and physics.
If you are an MSc in Artificial Intelligence or MBA in AI Product Management candidate at the Udacity Institute of AI and Technology, these repositories may help you work through the coursework. Use them for reference and follow the Udacity Honor Code: cite any material you draw on and submit only your own work. Caveat emptor - dura lex sed lex.
Attribution. Where a project began from a Udacity starter repository, the original TODOs, problem statement, and scaffolding are retained unmodified, and my contribution is documented separately in the same repository - typically in the updated README.md or in a Report.md, REFLECTION.md, or a delimited "Completed implementation" section. Supplied material is never presented as my own. Original starter scaffolding and TODO markers are retained for provenance; completed implementation is documented separately.
The Boston Housing project is retained as historical coursework and preserves the original program sequence and numbering. Removing it would create a misleading record of the curriculum and obscure the progression toward my later Responsible AI work. Retention is not endorsement: where older datasets or practices have known limitations, the repository can acknowledge that context rather than silently erase it.
Stay Udacious!