Portfolio

HARMONY Authorities Portal empowers health authorities, government health departments, and public health officials with real-time analytics from blockchain-backed health records, enabling early outbreak detection, resource optimization, and evidence-based policy decisions.

Key Innovation

Combines blockchain immutability with selective field encryption, giving authorities verifiable health data while preserving patient privacy. No patient identifiers exposed. Fetches encrypted records from blockchain nodes → Decrypts with AES-256-GCM → Preprocesses (normalize, aggregate, analyze) → Visualizes in interactive dashboard.

Impact: Reduces surveillance lag from weeks to hours, enables predictive resource allocation, detects anomalies with statistical rigor (z-scores, diversity indices), and provides transparent data quality metrics.

Core Features

• Statistical Reports Management: Upload multiple file formats (PDF, Word, Excel, PowerPoint, Images) with rich metadata including categories, regions, time periods. Public/private visibility controls with file download tracking and analytics.

• Advanced Analytics Dashboard: Blockchain health data integration with disease surveillance monitoring, vaccination trend analysis, environmental health metrics, and real-time health alerts and notifications.

• Real-Time Analytics: Fetches encrypted records from blockchain nodes, decrypts with AES-256-GCM, preprocesses data (normalize, aggregate, analyze), and visualizes in interactive dashboards. Features 5-minute server-side caching with automatic fallback to probe snapshots.

• Advanced Visualization: Time-series trends, geographic heatmaps, Sankey flow diagrams, and anomaly detection. Interactive charts with bubble/heatmap toggle, bar/treemap toggle for drug analysis.

• Evidence-Based Decision Making: Statistical baselines, z-score analysis, diversity indices, and growth metrics for resource allocation and seasonal planning.

• Disease Surveillance: Automated spike detection (z > 3σ), emerging disease identification, and regional outbreak monitoring with 60%+ growth rate alerts.

• Data Integrity Verification: Transparent field-level provenance (decrypted vs plaintext vs auth-failed) with real-time integrity dashboard showing decryption success rates.

• Search & Discovery: Advanced filtering by category, region, time period with full-text search across reports and metadata. Trending reports discovery and authority profile browsing.

Technical Architecture

• Frontend Stack: React 18 + TypeScript + Vite with Tailwind CSS custom authority theme, Radix UI components for accessibility, Wouter for client-side routing, React Query for server state management, React Hook Form with Zod validation.

• Backend Stack: Node.js + Express.js with TypeScript, Supabase for database and authentication, Multer for file upload handling, UUID for unique identifiers.

• Database & Storage: Supabase PostgreSQL with Row Level Security (RLS). Three main tables: authority_profiles (user profiles with verification), authority_stats (statistical reports), authority_stats_comments (collaboration threads).

• Blockchain Integration: Read-only analytics consumer of blockchain-backed health data. Parallel HTTP requests to Hospital API (localhost:48080) and Authorities API (localhost:48083) with bearer token authentication. Field-level decryption using AES-256-GCM with HKDF-derived keys.

• Analytics Pipeline: Server-side processing with 5-minute cache TTL, automatic fallback to probe snapshots if blockchain unavailable, integrity tracking for decrypted/plaintext/auth-failed fields.

• Preprocessing Pipeline: 500+ lines of pure transformation functions including data cleaning (label normalization, null handling), time filtering & bucketing (day/week/month), statistical aggregations (moving average, Shannon entropy, z-scores), and flow analysis (Sankey diagrams).

Analytics Dashboard Features

• Overview Tab: KPI cards (total patients, checkups, public records), regional distribution bar charts, top diseases, diagnosis→drug mapping (stacked bar), diversity over time (line chart), field integrity dashboard, emerging diseases list, top drugs (bar/treemap toggle), patient flow metrics.

• Disease Trends Tab: Line chart mode with 7-day moving average and spike markers (red dots when value > MA × 2), stacked area mode for proportional view showing shifting disease composition.

• Map & Flows Tab: Geographic intelligence with bubble/heatmap toggle, diagnosis→drug Sankey flow diagrams, anomalies & alerts with data-driven tables and z-score analysis.

• Regional Tab: Area-specific metrics including record counts per area, geographic hotspots list, 7-day growth by area, diversity per region (Shannon H).

Statistical Methods

• Moving Average (7-day): Smoothing time-series and detecting spikes • Shannon Diversity Index: Measures disease diversity in region/time period (H = -Σ p_i ln(p_i)) • Regional Growth Percentage: Compares last 7 days vs prior 7 days • Baseline Statistics (Z-Score): Number of standard deviations from baseline (z = (latest/days - μ) / σ) • Spike Detection: Detected when latest > MA × (1 + factor)

Security & Privacy

• Row Level Security (RLS) policies for data isolation • JWT-based authentication with Supabase • File upload validation and virus scanning • Rate limiting and CORS protection • Secure file storage with access controls • AES-256-GCM envelope encryption with authenticated encryption • Zero PII exposure - no patient identifiers visible to authorities

Key API Endpoints

• Authentication: /api/auth/register, /api/auth/me, /api/auth/profile • Statistics: /api/stats/upload, /api/stats/public, /api/stats/my-stats, /api/stats/:id • Analytics: /api/analytics/overview, /api/analytics/personal, /api/analytics/trending, /api/analytics/live (with force refresh support) • File Upload: /api/upload/avatar, /api/upload/files

Refresh Strategies

• Manual Refresh: Authorities click button → hits /api/analytics/live?force=1 → server bypasses cache, fetches fresh blockchain data → React Query refetches, UI updates immediately • Login-Triggered Refresh: Silent background refresh after authentication • Hourly Auto-Refresh: Silent updates every 60 minutes with fallback to cached snapshot on failure

How This Helps Authorities

• Early Outbreak Detection: Detect disease spikes within hours, not weeks (z-score analysis triggers automatic alerts) • Resource Allocation: Deploy resources to regions with 60%+ growth rates first • Seasonal Planning: Predict staffing needs 2-3 months ahead using 90-day baseline comparison • Disease Diversity Monitoring: Identify underserved areas for health equity initiatives (Shannon entropy per region) • Drug Utilization Review: Identify prescribing patterns for clinical guidelines validation • Data Quality Assurance: Real-time integrity dashboard with field-level provenance

This project demonstrates expertise in building secure, privacy-preserving public health surveillance systems that combine blockchain immutability with advanced analytics, statistical rigor, and evidence-based decision support for government health officials.

HARMONY Research Portal is an advanced medical research platform designed to bridge the gap between blockchain-secured healthcare data and actionable research insights. Built as an extension of the HARMONY healthcare system, this portal empowers researchers, medical professionals, and health authorities with privacy-preserving analytics, AI-powered research tools, and collaborative study environments.

Core Features

• Blockchain Integration: Connects to a Hyperledger Fabric network with four organizations (Hospital, Pharmacy, Research, Authorities) running dedicated API containers. All medical data is immutably stored with envelope encryption (AES-256-GCM) and accessible only through controlled endpoints.

• Real-Time Health Analytics: Dynamic analytics dashboard featuring temporal disease trends, geographic distribution, treatment effectiveness analysis, and disease-symptom co-occurrence patterns. Data flows from blockchain through decryption layers and caching services with 1-hour refresh cycles.

• Anonymization & Privacy: Implements minimum count thresholds (rare categories suppressed), label truncation, tri-state rendering for encrypted fields, and zero PII exposure. CNIC hashes never leak; all queries use keyword-based search.

• AI-Powered Research Assistant: Integrated Groq API (llama-3.3-70b-versatile) and HuggingFace inference for research paper summarization, medical Q&A, data analysis insights, and literature review assistance. Features 30-minute caching and automatic retry with exponential backoff.

• Study Rooms (Real-Time Chat): WebSocket-based instant messaging with public/private rooms, member management, room settings, and live notifications. PostgreSQL storage for rooms, memberships, and messages.

• Research Paper Management: Upload PDFs/DOCX with metadata (title, authors, tags, abstract), version control, peer review commenting, tagging system, and full-text search. Supabase storage backend with signed URLs (10-minute expiry) and 50MB file size limit.

• Advanced Analytics System: Service layer fetches raw blockchain data, decrypts envelope fields using master key, normalizes labels, aggregates counts, and caches snapshots by time window (today/week/month). Returns structured snapshots with totals, geographic distribution, top diseases, symptom/prescription correlations, and decryption diagnostics.

Technical Architecture

• Frontend: React 18 + TypeScript + Vite with Tailwind CSS, shadcn/ui, and Radix UI components. Recharts for data visualization (Bar, Line, Pie, Area charts).

• Backend: Node.js + Express REST API with JWT-based authentication, bcrypt password hashing, and role-based access control (Researcher/Admin roles).

• Database: PostgreSQL with Drizzle ORM for schema management and migrations.

• Storage: Supabase file storage for research papers with path structure <userId>/<researchId>/<filename>.

• Blockchain: Hyperledger Fabric private network with envelope encryption for all medical records. Master key derived via HKDF-SHA256 for analytics-only decryption.

• AI Integration: Groq API primary model with HuggingFace fallback, in-memory caching, and rate limiting.

• Real-time: WebSockets for study room messaging and live notifications.

Security & Compliance

• Data Encryption: AES-256-GCM envelope encryption at rest via blockchain envelopes with per-field keys and AAD.

• Access Control: Role-based permissions enforced at API layer with JWT token validation (7-day expiry).

• Anonymization: No PII in analytics; CNIC hashes only used for blockchain queries.

• Input Validation: Zod schemas on frontend and server-side validation for all endpoints.

• File Upload Security: Type and size restrictions, signed URLs for downloads, virus scanning integration-ready.

Key Endpoints

• Blockchain: /patient/register, /patient/vitals, /patient/checkups, /patient/history/:cnicHash, /stats/basic, /research/keyword, /authorities/stats

• Analytics: /api/analytics/snapshot (time window support), /api/analytics/insights (AI-generated)

• AI: /api/openai/chat, /api/openai/summarize, /api/openai/analyze-research

• Study Rooms: /api/study-rooms (CRUD), /api/study-rooms/:id/messages, /api/study-rooms/:id/members

• Research: /api/research (upload/list), /api/research/:id/comments, /api/research/:id/versions

This project demonstrates full-stack expertise in building secure, scalable healthcare research platforms that prioritize data privacy, researcher collaboration, and actionable medical insights through cutting-edge blockchain and AI technologies.

BlockBoard Cosmos is a practical blockchain engineering project built to demonstrate deep Cosmos-native development skills while preserving strong frontend product quality. The core objective is to implement a simple but complete decentralized application: users connect a wallet, post a short message to chain, and immediately read updated on-chain state (last message and message count).

From an architecture perspective, the project follows a clean, production-aligned pattern. The frontend (React + Vite) acts as a thin client using CosmJS for all blockchain interactions. Wallet signing is abstracted through Cosmos Kit adapters to support both Keplr and MetaMask (Leap Cosmos Snap), enabling a modern multi-wallet UX without introducing backend custodial logic. The blockchain backend is a local CosmWasm-enabled wasmd chain running in Docker, configured with deterministic local development behavior and exposed RPC/REST endpoints for rapid iteration and testing.

The smart contract is implemented in Rust using CosmWasm conventions: typed execute and query messages, explicit state management, and predictable validation rules. The execute path enforces message quality constraints (including length limits) and emits state transitions that are queryable from the UI. This demonstrates clean contract API design, safe state updates, and deterministic behavior under transaction execution. The query path provides efficient read endpoints for UX rendering, making it straightforward to build responsive interfaces around on-chain data.

The project also demonstrates strong developer-experience practices expected in professional teams. It includes repository segmentation by concern (contracts, frontend, local-chain, docs, scripts), local-first setup flow, deployment documentation, and helper scripts for funding and testing. The frontend enforces required environment configuration at startup to prevent silent runtime misconfigurations, which is a valuable reliability pattern for collaborative engineering environments.

A key differentiator is wallet interoperability. Beyond standard Keplr support, the app integrates MetaMask through the Leap Cosmos Snap pathway. This reduces onboarding friction for Ethereum-native users while preserving Cosmos transaction semantics and bech32 account behavior. The UI can present Cosmos addresses and derived Ethereum-style display addresses, helping users understand identity mapping across ecosystems and improving product accessibility for mixed-wallet audiences.

This project is portfolio-relevant for blockchain and full-stack roles because it proves capability across all critical layers: chain operations, contract engineering, wallet integration, RPC/REST usage, transaction lifecycle handling, and frontend UX reliability. It reflects hands-on delivery skills rather than isolated code snippets, and it demonstrates the ability to ship and operate an end-to-end decentralized product in a realistic development workflow.

Mirror Vault is a hybrid Layer 1 blockchain built to solve ecosystem fragmentation between Cosmos-native applications and EVM-based applications. Instead of forcing users to manage separate wallets, keys, and bridge workflows, the chain is designed around a unified identity model where one private key controls both a Cosmos bech32 address (mirror1...) and an Ethereum hex address (0x...).

Core Value

Mirror Vault combines Cosmos SDK performance and modularity with Ethereum smart contract compatibility on the same chain. This enables teams to build high-throughput native modules in Go while still delivering familiar Solidity/Web3 experiences for wallets and dApps.

Key Features

• Unified Identity Mapping: A single BIP-44 key derivation path with EthSecp256k1 enables synchronized Cosmos and EVM addresses with shared account ownership semantics.

• Hybrid Execution Model: Cosmos SDK modules handle canonical state and protocol-level logic, while Cosmos EVM executes Solidity contracts and exposes Ethereum-compatible behavior.

• Bridgeless UX: Users can interact through Keplr and MetaMask without relying on wrapped assets and cross-chain bridge flow for basic asset visibility and account operations.

• Native + Smart Contract Flexibility: Performance-critical logic can be implemented in Cosmos modules, while composable user-facing logic is delivered via Solidity contracts.

Technical Architecture

• Consensus Layer: CometBFT (Tendermint) provides BFT finality with configured low-latency block production.

• State Layer: Cosmos SDK powers account, bank, staking, and distribution modules, with custom module extensions for domain-specific logic.

• EVM Layer: Cosmos EVM (Ethermint) integration enables EVM execution and Ethereum JSON-RPC compatibility for wallet and tooling support.

• Identity Layer: Address mapping aligns Cosmos and EVM identity surfaces from the same cryptographic key material.

Implementation Highlights

• Operational Cosmos chain with validator setup, funded test accounts, and verified transfer flow.

• Reproducible build system with isolated Go toolchain and environment standardization scripts.

• Stabilized module wiring and genesis configuration for denom consistency, module accounts, and runtime initialization.

• Active development on manual EVM keeper wiring, JSON-RPC enablement, and cross-VM interaction paths.

Engineering Challenges Solved

• Resolved Go toolchain and dependency compatibility constraints for Cosmos/EVM builds.

• Addressed dependency-injection conflicts in EVM signer wiring through provider-based initialization patterns.

• Fixed EVM module account initialization issues by explicitly configuring required module account permissions.

• Eliminated bond-denom mismatches to keep staking and token economics consistent across genesis and runtime.

Roadmap

• Complete Cosmos EVM integration and validate end-to-end MetaMask compatibility.

• Implement custom x/vault module and Solidity VaultGate contract for business-grade encrypted data and access workflows.

• Add cross-VM precompile path for Solidity-to-Cosmos module invocation.

• Deliver a Next.js dashboard for unified account visibility, transaction flows, and cross-VM UX.

This project demonstrates advanced blockchain engineering across consensus systems, state-machine architecture, cryptographic identity design, EVM interoperability, and production-focused infrastructure practices.

Lead Enricher Pro is a no-code data enrichment pipeline built in n8n. Starting from basic company details in Google Sheets, the workflow automatically discovers official websites, enriches profiles with social links (Facebook, Instagram, TikTok, LinkedIn, Yelp, YouTube, X/Twitter), and verifies executive contacts via Hunter.io.

Search queries are generated per company to improve precision, results are validated and cleaned in lightweight Code nodes, and everything is merged into a consistent structure. The final output writes back to the source Google Sheet in real time—saving hours of manual prospecting and research.

HARMONY is my final year project aimed at addressing critical challenges in the healthcare sector by leveraging blockchain technology. Traditional healthcare systems often face issues such as data breaches, mismanagement of patient records, lack of transparency in research data, and administrative inefficiencies. HARMONY tackles these problems by introducing a decentralized platform where patients, doctors, administrators, and researchers can interact seamlessly while ensuring data security and trust.

The system enables patients to have complete control over their medical records, granting access only to authorized healthcare professionals through smart contracts. Hospitals and administrators benefit from streamlined workflows such as appointment scheduling, billing, and inventory management, all while reducing the risk of fraud and human error. Researchers gain access to anonymized, verified datasets, fostering collaboration and innovation without compromising patient privacy.

By integrating blockchain with AI/ML and data science principles, HARMONY ensures predictive analytics for patient care, transparent data sharing for researchers, and efficient decision-making for administrators. The goal is not only to secure sensitive healthcare data but also to build a system that promotes accountability, reduces redundancies, and improves the overall quality of healthcare delivery.

This project highlights my ability to design, architect, and implement a full-fledged solution that bridges multiple domains—healthcare, blockchain, artificial intelligence, and administration—while addressing real-world challenges with cutting-edge technology.

SecureVault is a project designed to simplify secure file storage and sharing using state-of-the-art encryption principles. Traditional file-sharing platforms often place sensitive data at risk due to weak encryption, centralized storage vulnerabilities, or lack of user control. SecureVault addresses these challenges by giving users full ownership of their files through zero-knowledge encryption, ensuring that no one—including the platform itself—can access the contents without the user’s password.

Users log in seamlessly through Google Authentication for a secure and convenient onboarding experience. Once authenticated, they can upload any file and encrypt it with a password of their choice using AES-256 encryption combined with hashing techniques to strengthen security. The system generates a downloadable encrypted file that can be shared with anyone. Decryption requires only the correct password, ensuring the principle of zero knowledge remains intact.

A personalized dashboard allows users to view their history of encrypted and decrypted files, track activity, and manage access. The platform uses Supabase as a backend with a Base44-inspired architecture for data handling and performance optimization. By combining React, TailwindCSS, and Supabase, the project ensures both a sleek UI/UX and a robust, scalable backend. SecureVault highlights my ability to build privacy-first, user-centered applications that merge security, usability, and modern web technologies.

StartEase is a ready-to-use website template crafted for new startups and small businesses aiming to establish their digital presence quickly. It offers all the essential sections like Hero, About, Services, Testimonials, Team Members, Happy Clients, and a Contact Form in a clean and attractive layout. Designed with scalability and ease of use in mind, StartEase provides Firebase authentication for content management, enabling startups to update their website without hassle. Built with React and CSS on the frontend, and a Node.js backend, it delivers performance, responsiveness, and simplicity. StartEase helps startups save time, reduce costs, and focus on their business while ensuring their website looks professional and trustworthy.

A web-based SQL Server Query Optimizer that accepts SQL queries, analyzes their performance using built-in tools, and provides suggestions for optimization. Designed as a RESTful service using Python Flask, it assists developers and DBAs in identifying inefficient queries and improving overall database performance.

Features • Accepts SQL queries via web interface. • Analyzes Execution Plans to detect bottlenecks. • Utilizes SQL Server DMVs for performance insights. • Provides optimization suggestions for better query performance. • Lightweight Flask-based backend with a simple HTML frontend.

Technologies Used • Python (Flask) • HTML / CSS (Frontend) • SQL Server (Performance Analysis) • DMVs & Query Execution Plans

Cryvanta was designed as a complete end-to-end engineering project to demonstrate practical product delivery across frontend experience, backend architecture, data engineering, and security. Instead of functioning as a speculative trading app, Cryvanta focuses on decision-support intelligence: users can track live market performance, inspect volatility and momentum indicators, and monitor assets through personalized watchlists with alerting workflows.

From a technical architecture perspective, the platform follows a clean separation of concerns. The frontend is built with React 18 and Vite, using modular page/component design and a responsive UI system that works across desktop and mobile. The backend is an Express API service organized into domain layers (routes, services, analytics, models, middleware), with MongoDB for persistence and Mongoose as the data modeling layer. This separation enables independent evolution of UI, analytics logic, and API contracts.

Cryvanta integrates external market data providers (CoinGecko and Binance fallback flows) and normalizes that data into consistent API responses suitable for charts, rankings, and insight generation. The analytics engine includes volatility calculations, momentum analysis, and SMA crossover signals, creating a portfolio-ready demonstration of quantitative processing beyond simple price display.

A major strength of Cryvanta is reliability-oriented engineering discipline. The backend includes rate limiting, secure headers via Helmet, password hashing with bcrypt, JWT authentication using HTTP-only cookies, CORS controls, and structured logging. Environment-based configuration and startup validation reduce runtime misconfiguration risks. The codebase also includes Docker-based local infrastructure for repeatable development setup, specifically for MongoDB services.

The project is portfolio-relevant because it demonstrates strong full-stack ownership: UI implementation, API design, data integration, caching concepts, authentication/security controls, and deployable local development workflows. It reflects the ability to ship and operate a modern data-driven web application from architecture through execution, with clear pathways for future scaling into richer AI and analytics features.

EVMBridgeBoard is an end-to-end interoperability project built to prove a practical and often misunderstood concept in Web3 product engineering: one blockchain can expose both EVM and Cosmos wallet experiences without requiring bridges, wrapped assets, or duplicated state. The project uses an Ethermint/Evmos-style chain to provide Ethereum JSON-RPC compatibility while preserving Cosmos-native account and ecosystem semantics.

From a product perspective, EVMBridgeBoard delivers a dual-wallet message board where users can connect with MetaMask or Keplr, submit on-chain messages, and observe identical contract state from either wallet. This validates wallet-level parity for real user operations including account connection, transaction signing, gas payment, message writes, and state reads. The same state root is queried through shared RPC infrastructure, making results deterministic and consistent.

Architecturally, the system is intentionally separated into three layers. The blockchain layer runs a local Evmos-compatible node in Docker with JSON-RPC (8545), Tendermint RPC (26657), and Cosmos REST (1317). The smart contract layer is implemented in Solidity (MessageBoard.sol) and deployed through Hardhat scripts configured for the local EVM chain (chain ID 9000). The frontend layer is a browser-based JavaScript application that integrates Ethers.js for EVM transactions and Keplr APIs for Cosmos-style wallet interactions, with a unified UI for wallet switching and transaction observability.

A core technical achievement is address and identity coherence. EVMBridgeBoard demonstrates secp256k1-based key compatibility where one private key can be represented in both address formats (hex 0x... and bech32 evmos...). This enables developers and reviewers to validate how wallet UX differences map to the same cryptographic account lineage and on-chain state authority.

The implementation also emphasizes professional engineering practices expected by hiring teams: containerized local infrastructure, scriptable startup/deployment workflows, modular repository boundaries (chain/contracts/frontend), transaction and gas visibility, and comprehensive operational documentation for setup, testing, and troubleshooting.

For portfolio evaluation, EVMBridgeBoard demonstrates practical depth across blockchain infrastructure, EVM contract development, Cosmos ecosystem integration, wallet interoperability, and frontend delivery. It shows the ability to design and execute a multi-protocol system that is not only technically correct but also demonstrable in a browser with reproducible developer workflows.

MessageBoard-EVM is a complete local-first blockchain application that showcases practical Web3 engineering across contract, infrastructure, and frontend layers. The product concept is intentionally simple and verifiable: users connect MetaMask, submit a short message to a deployed smart contract, and instantly view synchronized on-chain state updates such as the latest message and total message count.

The core value of this project is not just UI demonstration, but full transaction lifecycle execution. The frontend uses ethers.js to connect through window.ethereum, reads contract state with free view calls, submits signed transactions for message posting, tracks transaction hashes, waits for confirmation, and refreshes state after finality. This captures real dApp behavior expected by engineering teams and product stakeholders.

On the smart contract side, BlockBoard is written in Solidity 0.8.x with clear constraints and predictable state transitions. The contract enforces input limits (140-character maximum), stores public state variables for direct query access, and emits events for transparent state-change observability. The codebase includes Hardhat tests and deployment scripts to support repeatable developer workflows.

The local infrastructure is designed for reliability and speed. Hardhat node provides deterministic local RPC (127.0.0.1:8545, chain id 31337), while deployment scripts automatically publish ABI and contract address into the frontend contract configuration file. This removes manual copy/paste errors and creates a reproducible setup that is easy to onboard and review.

From a hiring and portfolio perspective, MessageBoard-EVM demonstrates hands-on capability in blockchain product execution: Solidity contract modeling, local network operations, secure wallet-based transaction signing, frontend smart contract integration, and robust dev workflow automation. It reflects practical delivery competence and readiness for real-world Web3 engineering tasks.

Sentinel-Net is an end-to-end machine learning product built to solve a practical trust problem in automated text classification: high accuracy alone is not enough unless predictions are explainable, auditable, and operationally reliable. The platform classifies SMS messages as spam or ham using a multi-agent ensemble architecture, then returns both the final decision and the rationale behind that decision in a developer- and stakeholder-friendly format.

The core backend is implemented in Python with FastAPI and a modular architecture spanning model loading, preprocessing, consensus logic, API routing, and persistence adapters. Rather than relying on a single model output, Sentinel-Net orchestrates multiple classifiers (Naive Bayes, Random Forest, Logistic Regression, with SVM pipeline expansion) and combines their votes using Relative Weighted Plurality Voting (RWPV). This approach improves robustness under noisy inputs and reduces single-model bias, while preserving per-agent confidence visibility for analysis and debugging.

From an engineering perspective, the API layer includes production-minded controls such as CORS restrictions, trusted host checks, request validation middleware, timeout guards, and rate limiting. The startup lifecycle initializes models, consensus engine state, and data preprocessor dependencies in a predictable sequence, helping avoid partial-start failures in local and deployment environments.

The frontend is built with Next.js and TypeScript to deliver a responsive, real-time classification and analytics experience. It integrates with the backend API for predictions and status information, and supports operational workflows such as monitoring model agreement patterns, reading explanation signals, and inspecting confidence distributions. The interface emphasizes clarity for both technical and non-technical users, making the system suitable for demos, internal reviews, and stakeholder presentations.

Sentinel-Net also reflects strong project discipline: comprehensive documentation, phased implementation records, security hardening notes, database migration artifacts, and test strategy coverage. For portfolio evaluation, this project demonstrates practical competence across ML engineering, secure API development, frontend product delivery, and production-aware system design. It is a strong example of shipping a complete AI-powered application rather than isolated notebooks or model scripts.

Description A custom GPT-powered automation designed to streamline receipt management. Users can upload receipts (PDFs, images, or text), and the system automatically extracts key data such as date, vendor, amount, and items. The GPT automation verifies missing details by prompting the user, ensuring complete accuracy before proceeding. Once confirmed, the structured data is inserted into a connected Google Sheet for easy record-keeping and reporting. Finally, the automation responds with a success message, providing a smooth end-to-end experience.

Key Features

Upload receipts in various formats (PDF, image, text).

GPT automation extracts and structures receipt details.

Interactive validation: asks user for missing or unclear fields.

Checks for duplicates before inserting into Google Sheets.

Inserts clean, structured data into Google Sheets in real time.

Sends back a success message to the user for confirmation.

Tech Stack

GPT (Custom Prompting) → for receipt data extraction & validation.

Make.com → orchestrates workflow and automation.

Webhook Integration → connects GPT with Make.com & Google Sheets.

Google Sheets API → stores structured receipt data.