📞 Get In Touch
I am a software engineer with a passion for building robust, efficient, and well-designed systems. My work spans the full spectrum of technology, from low-level systems programming and operating systems fundamentals in C and Assembly to high-level, AI-driven applications and full-stack web services. This portfolio is a curated collection of my projects, reflecting a commitment to understanding computer science from first principles and applying that knowledge to solve complex problems. I believe that a deep comprehension of how memory is managed, how schedulers operate, and how databases process queries is essential for creating truly exceptional software at any level of the stack.
My approach is grounded in modern software engineering practices, including rigorous testing, containerization for reproducible environments, and a focus on creating clean, maintainable code. Whether it's implementing a custom memory allocator, architecting a multi-modal AI application, or deploying a full-stack web service, my goal is to deliver solutions that are not only functional but also thoughtfully engineered.
| Languages & Runtimes | Frontend | Backend & APIs | Data & ML | Databases & Storage | DevOps & Cloud |
|---|---|---|---|---|---|
           |
              |
         |
              |
       |
             |
| IDEs & Editors | Version Control & PM | OS & Virtualization | Networking & Security | Testing & QA | Build · Package · Misc |
|---|---|---|---|---|---|
         |
      |
      |
        |
     |
                   |
RoboDoc is a multi-modal AI application designed to explore the potential of machine learning in healthcare decision support. Built with Python and Streamlit, it integrates three distinct AI modules into a single, interactive platform. This project showcases the ability to build and integrate complex ML models into a user-friendly application, with a strong emphasis on model explainability, a critical component for trust in AI systems.
-
SBERT-Powered Clinical Q&A: A sophisticated chatbot that uses Sentence-BERT embeddings to understand and answer clinical questions based on a built-in medical knowledge base.
-
Biomarker-Based Disease Classifier: A classic machine learning model that predicts the likelihood of a disease based on patient biomarker data.
-
Explainable Survival Predictor: A model that predicts patient survival outcomes and, crucially, uses SHAP (SHapley Additive exPlanations) to provide visual explanations of which factors contributed most to its prediction.
-
Technologies: Python, Streamlit, Scikit-learn, SBERT, SHAP, Pandas.
https://github.com/r-siddiq/RoboDoc
A full-stack, multi-modal decision support ecosystem designed to unify fragmented oncology data into a single intelligent workspace. Onco-Logic combines NLP over pathology reports, ML on gene expression, and survival prediction models into a cohesive, interactive Streamlit application that enables explainable, patient-specific insights for clinicians and researchers.
-
End-to-End Precision Pipeline: Integrates clinical text, genomic profiles, and survival outcomes into a unified platform for comprehensive cancer decision support.
-
Advanced Clinical NLP (Pathfinder-NLP): Uses transformer-based models to extract structured entities, staging, and prognostic signals from unstructured pathology reports.
-
Genomics & Survival Modeling: Implements gene expression–based cancer subtype classification and breast cancer survival/risk prediction with robust modeling, resampling, and interpretability.
-
Technologies: Python, Streamlit, PyTorch, scikit-learn, Transformers, spaCy, SHAP, UMAP, Git LFS.
An autonomous trading platform combining real-time ML signal generation with automated trade execution. ShadowDesk implements a full ML pipeline—data ingestion, feature engineering, model training with XGBoost, and deployment via FastAPI—containerized with Docker Compose for local development and orchestrated with Kubernetes and ArgoCD for production GitOps workflows.
-
Real-Time ML Inference: FastAPI service generating trading signals from XGBoost models trained on hourly stock data with technical indicators (SMA, RSI, MACD, Bollinger Bands).
-
Automated Trade Execution: Alpaca broker integration supporting paper and live trading with full order lifecycle management.
-
Complete ML Pipeline: Airflow-directed workflow orchestrating data ingestion, feature engineering, model training, validation, and deployment with MLflow tracking.
-
Observability Stack: Prometheus metrics collection and Grafana dashboards for system-wide monitoring.
-
Infrastructure as Code: Docker Compose for local development, Kubernetes manifests with ArgoCD GitOps deployment, and sealed secrets for secure credential management.
-
Technologies: Python, FastAPI, Streamlit, Airflow, MLflow, XGBoost, MinIO, Qdrant, Vault, Docker, Kubernetes, ArgoCD, Prometheus, Grafana.
A self-contained, security-first proxy framework that mediates access between AI coding agents and MCP-compatible tools with policy enforcement, secret management, and browser automation. MCP-Warden acts as a secure gateway—inspecting every request and response, injecting API keys only where needed, and blocking dangerous operations—enabling agents to safely use powerful host tools without exposing secrets, host sockets, or privileged capabilities. Deployed via portable Docker Compose with a cross-platform launcher.
-
Zero-Trust Container Hardening: All services run as non-root with dropped capabilities, read-only root filesystems, no-new-privileges enforcement, memory/CPU limits, and an isolated internal network—only the policy enforcement boundary is exposed to the host.
-
Policy Enforcement Engine: Controller inspects all MCP JSON-RPC traffic, applying allow/block lists for tools, validating arguments against schemas, detecting nested/injected tool invocations to prevent prompt injection bypass, blocking SSRF attacks against internal IPs, and sanitizing responses for sensitive data (cookies, auth headers, CDP references).
-
Secret Broker with Template Injection: Secrets stored on the host in a gitignored directory are mounted as Docker secrets and injected upstream by the broker—API keys never reach the controller or agent container.
-
MCP Session Gateway: Custom session-persistent proxy captures and replays
Mcp-Session-Idtokens across MCP lifecycle chains, with path-based routing to upstream tools and TTL-based session pruning. -
Agent Sandbox: Generic Ubuntu runtime with persistent home volume supporting "bring your own tools"—users install their preferred AI CLI tool with no access to secrets, Docker socket, or host filesystem beyond a writable workspace.
-
Tool Suite: Integrated browser automation via Playwright MCP connecting to host Chrome through CDP with persistent profiles, plus a custom Obsidian MCP adapter for knowledge management through the Obsidian Local REST API.
-
Technologies: Python 3.12, Node.js, Docker, Docker Compose, MCP (Model Context Protocol), Playwright, CDP (Chrome DevTools Protocol), httpx, pkg.
A full-stack, production-style Learning Management System engineered for real-world university operations. Lyceum delivers a secure, role-based experience for administrators, instructors, and students, backed by a refactored monolith-to-microservices Java backend and a modern React SPA frontend. The system showcases architectural evolution, asynchronous communication, and cloud-ready deployment patterns.
-
Full-Stack System Design: React single-page application consuming secure REST APIs from dedicated backend services, modeling real academic workflows end-to-end.
-
Service-Oriented Backend: Java 17 + Spring Boot architecture split into Registrar and Gradebook services, decoupled via RabbitMQ for asynchronous messaging, clean data ownership, and scalable domain boundaries.
-
Role-Based UX & Security: Distinct portals and flows for Admins, Instructors, and Students, backed by JWT-based authentication, authorization, and guarded routes across the stack.
-
Cloud & DevOps Ready: Containerized services with MySQL persistence, designed for deployment on AWS (ECS/RDS/load balancing), reflecting production deployment considerations.
-
Technologies: Java 17, Spring Boot, Spring Security, Spring Data JPA, RabbitMQ, MySQL, Maven, JUnit/Mockito, Docker, React 18, Vite, Material-UI, HTML/CSS/JS.
This project is a C-based simulation of a Memory Management Unit (MMU), a fundamental hardware component in modern computers. By implementing this from scratch, I explored the core mechanics of virtual memory, which underpins how operating systems provide memory safety and efficiency. VirtuMMU translates virtual addresses to physical addresses, simulates page table lookups, and enforces memory protection. This work demonstrates a deep, practical understanding of computer architecture and low-level operating system design.
-
Core Functionality: Simulates virtual-to-physical address translation using a hierarchical page table structure.
-
Memory Protection: Implements read, write, and execute permissions at the page level, a cornerstone of modern OS security.
-
First-Principles Approach: Built entirely in C with no external libraries, focusing on the fundamental algorithms and data structures involved in memory management.
-
Technologies: C, Makefiles.
Culinary Otter is a deployed, server-rendered Node.js web application for discovering and managing recipes. This project demonstrates the ability to build a complete, user-facing product, integrating multiple third-party APIs and managing a persistent relational database. It features a full authentication system, session management, and an operational mindset with features like automated daily data resets. The architecture is a classic server-side rendering (SSR) model, which is highly effective for content-driven sites.
-
Full-Stack Architecture: Built with Node.js and Express, serving dynamic HTML pages templated with EJS and backed by a MySQL database.
-
Multi-API Integration: Enriches user experience by fetching recipe data from the Spoonacular API and real-time pricing information from the Kroger API.
-
User & Session Management: Includes secure user registration, login, and session persistence, allowing users to save and manage their favorite recipes.
-
Technologies: Node.js, Express, EJS, MySQL, Docker, Spoonacular API, Kroger API.
This repository is not just a collection of algorithm solutions but a rigorously engineered software portfolio. It contains modern C++17 implementations of a wide range of classic data structures and algorithms, all organized within a professional CMake build system and validated with CTest unit tests. This project showcases a commitment to algorithmic excellence and high-quality software engineering practices, including modularity, testing, and clean code.
-
Comprehensive Coverage: Includes implementations of graphs (adjacency lists/matrices), hash tables, heaps, various sorting algorithms, dynamic programming solutions, and topological sorting.
-
Modern C++: Utilizes C++17 features for clean, efficient, and safe code.
-
Professional Tooling: Employs CMake for a cross-platform build system and CTest for a structured unit testing framework, demonstrating a professional development workflow.
-
Technologies: C++, C++17, CMake, CTest.
My work in AI begins with a strong foundation in data science principles and classic machine learning, progressing to the development of specialized, application-driven AI systems.
- Machine Learning & Data Science Monorepo: A structured collection of Jupyter Notebooks that serves as my personal knowledge base. It covers everything from data wrangling with NumPy and pandas to model building and evaluation with scikit-learn, emphasizing reproducible and well-documented practices.
- RoboDoc: An AI-powered medical decision-support application featuring an SBERT chatbot, a disease classifier, and a survival predictor with SHAP explainability.
https://github.com/r-siddiq/RoboDoc
- Onco-Logic (Fork): A fork of a comprehensive, multi-modal decision-support ecosystem for oncology. My contributions and exploration within this project focus on integrating fragmented patient data and leveraging advanced AI/ML to provide holistic patient views for clinicians.
- Product Signal Control Tower: A human-in-the-loop n8n workflow for product feedback using PostgreSQL/pgvector, OpenTelemetry, and Playwright. The 21 gates are an evaluation plan; four Playwright scenarios passed against a local mock.
- Audit AI Enablement: A strategy deck outlining governed AI adoption and assurance approaches for audit teams.
- Judge Grid: A proposed benchmark design for human-calibrated model evaluation and cost/performance routing.
- LLM-Nexus: Research into Codex orchestration protocols, with a Terminal-Bench runner and analysis tools.
I have experience building both server-rendered and client-side web applications, with a focus on creating robust backends and interactive user experiences. Many of these projects are deployed and include operational considerations beyond simple development, such as health-check endpoints and automated data management scripts.
- Misc Front-End Projects: A collection of eight front-end and Express/EJS projects, consolidated in one repository with their histories retained.
-
Culinary Otter: A server-rendered Node.js/Express recipe app with MySQL, multi-API integration, and user authentication.
-
Docwright: A PHP/SQLite document-publishing prototype with scheduling, search, share links, and audit logging.
This collection of projects demonstrates a firm grasp of the low-level concepts that power all modern software. Building these systems from the ground up in C provides an invaluable perspective on performance, concurrency, and resource management.
- VirtuMMU: A C-based simulation of a Memory Management Unit, modeling virtual-to-physical address translation and memory protection.
- Mallocator: A custom memory allocator implemented in C, replacing the standard
malloc/free. It manages a memory arena with block splitting and coalescing to minimize fragmentation, showcasing a deep understanding of heap memory management. - ThreadNexus: A multithreaded TCP server in C that manages a shared database. It explores concurrency primitives (pthreads), synchronization with mutexes, and the design of thread-safe data structures, complete with unit tests to validate concurrent behavior.
- PULSE (CPU Scheduler Simulator): A C simulator for classic CPU scheduling policies like round-robin and FIFO. It uses a pluggable architecture to model both preemptive and non-preemptive scheduling, reinforcing core OS concepts.
https://github.com/r-siddiq/PULSE
- Strings and Ciphers: A modern C11 codebase implementing string manipulation utilities and classic ciphers. It demonstrates best practices in C programming, including the use of Makefiles for automated builds and the Criterion framework for unit testing.
My experience with databases extends from application-level design and querying to the rare and valuable work of implementing database engines from first principles. This dual perspective provides a unique advantage in designing and optimizing data-intensive applications.
- BitMatrix (Java RDBMS): A mini relational database management system built in Java. It supports schema definition, data insertion, and querying for both in-memory and file-backed tables, including basic indexing and query optimization.
- NatJoin (Java in-memory DB): A simple in-memory database system in Java with a focus on implementing a natural join algorithm from scratch, illustrating how core relational operations work at a low level.
https://github.com/r-siddiq/NatJoin
- HeapQuery (Java in-memory DB): An in-memory database system that supports data manipulation and boolean query conditions, with an emphasis on using in-memory data structures and serialization for persistence.
- SchemaCraft: A lightweight Java toolkit for defining schemas, creating typed tables, and performing relational operations. It uses Java NIO (
ByteBuffer) for low-level data management and is thoroughly tested with JUnit.
- DB Solutions (SQL Portfolio): A collection of SQL scripts demonstrating proficiency in relational database design, including schema creation, complex queries, and data modeling in MySQL.
- Prescription Webapp (NoSQL): A Spring Boot web application using MongoDB to manage healthcare data. It demonstrates CRUD operations and web UI development in a NoSQL, document-store context.
- Prescription Webapp (JDBC): A Spring MVC web app backed by a relational database via traditional JDBC. It highlights a multi-role workflow and secure data handling in a classic MVC architecture.
- LibraTrack: A Java/Gradle project modeling a library system. It demonstrates object-oriented design for a persistent system, using file handling for storage and JUnit for reliability testing.
I have experience building native Android applications using Java and modern Android Jetpack components, following best practices like the MVVM architectural pattern.
- GymLog: An Android workout tracker built with Java following the MVVM architecture. It uses Room (SQLite) for local persistence, LiveData for reactive UI updates, and RecyclerView for displaying lists of user-specific exercise logs.
https://github.com/r-siddiq/GymLog
- Pill Hub: A native Android pharmacy management app built with Java and Room. It demonstrates a multi-user system where patients can manage their prescriptions and admins can manage the drug inventory, all within a clean MVC-like structure.
- C↔F Converter: A simple native Android app for temperature conversion. It demonstrates fundamental concepts like navigation between Activities using Intents and UI management with ViewBinding.
- Android LifeCycles: A demo app written in Java to illustrate the Android Activity lifecycle. It logs all lifecycle callbacks (
onCreate,onStart, etc.) and shows how to persist UI state across configuration changes like screen rotations.
These projects focus on socket programming, concurrency, and network security. A recurring theme is the use of Docker and Mininet to create reproducible and realistic environments for testing network applications.
- SecureNexusNetwork: A multi-client chat service written in Python that features TLS encryption for secure communication. It offers two deployment modes: a simple Docker Compose setup and a more advanced Mininet-based virtual network simulation for in-depth analysis.
- Thread Chat: A Python TCP chat service focused on threading and automation. It is fully containerized with Docker and includes interactive demos, showcasing socket programming, concurrency, and health checks.
- Packet Pulse: A Python-based UDP "pinger" and heartbeat monitor. It simulates round-trip time measurements, packet loss, and heartbeat messages, demonstrating low-level UDP socket programming.
- Client-Server Socket Demo: A Python UDP client/server demonstration provided in both Dockerized and Mininet-based versions, highlighting message passing and techniques for testing network programs in isolated environments.
This collection of Java projects focuses on core object-oriented programming principles, design patterns, and algorithmic thinking. Each project is well-tested with JUnit to ensure correctness.
- Battle Strategy (Design Pattern): A Java project demonstrating the Strategy Design Pattern by implementing interchangeable "battle behaviors" for game characters. It showcases clean, extensible OOP design by separating algorithms from the objects that use them.
- Markov Text Generation: A Java program that generates new text based on the statistical properties of an input file using Markov chains. It highlights the use of data structures (like HashMaps) to build transition tables and demonstrates probabilistic algorithms.
- Trooper Maker: A Java project that models a Star Wars character hierarchy, demonstrating core OOP principles like inheritance, encapsulation, and polymorphism. It includes proper
equals()/hashCode()overrides and JUnit tests. - Histogram (Letter Frequency): A Java program that reads text files and builds letter-frequency histograms. It demonstrates file I/O, exception handling, and the use of collections, with thorough JUnit 5 tests.
A strong house is built on a solid foundation. These repositories represent a methodical and deliberate approach to mastering the fundamentals of programming and computer science theory, from the lowest level of abstraction up.
- Assembly Language Basics: A repository of x86 assembly programs demonstrating low-level concepts like procedures, stack frames, branching, array manipulation, and making system calls for I/O.
- Discrete Structures (C++): A collection of C++ programs that implement concepts from discrete mathematics, such as propositional logic evaluators, set operations, permutations, and recursion. These exercises bridge the gap between mathematical theory and executable code.
- Data Structures & Algorithms Portfolio (C++): A modern C++17 portfolio of classic data structures and algorithms, built and tested with CMake/CTest.
- C++ Foundations: A set of introductory C++ console programs covering vectors, strings, dynamic memory, linked lists, and basic sorting, all built with CMake.
- Java Foundations: A series of fundamental Java exercises focusing on console I/O, arrays, exceptions, and basic OOP principles, reinforcing core language concepts.
- Python Foundations: A beginner-friendly collection of Python programs covering user input, functions, loops, and error handling, including simple games and turtle graphics demos.