// all projects01

Project Showcase

High-impact mobile applications, scalable cloud backends, government reporting systems, and automated scheduling engines.

Agentic RAG Copilot for On-Call EngineersRelease: 2026

RAG Copilot

An AI copilot for on-call engineers. Ask "Why is the payments service showing a latency spike?" and it pulls runbooks and live telemetry, diagnoses the cause, proposes a fix, and executes it after human approval.

Role & Contribution:Solo Developer & Creator

Designed and built the agent workflow, RAG pipeline, approval flow, Kubernetes integration, evaluation harness, and React UI.

Problem: On-call engineers piece together runbooks and telemetry by hand during incidents, and letting an AI act on production is unsafe without strict limits.

Architecture: A LangGraph workflow retrieves runbooks (RAG over pgvector) and evidence from Prometheus, Loki and Tempo in parallel, then the LLM gives a structured diagnosis and picks an action from a typed list. Approved fixes run on Kubernetes and are verified against metrics.

Technical Decisions: Built the RAG pipeline on PostgreSQL and pgvector: Markdown split by headings, re-ingestion that skips unchanged documents, a vector index with filtered search, and a startup check that refuses to mix vectors from different embedding models. Defended against prompt and query injection: untrusted text is clearly marked in prompts, all model output is validated, queries come from fixed templates, and a person must approve every action. High-risk actions need a second superuser, and each action executes exactly once. Instrumented the AI itself with OpenTelemetry: one trace per run with a span for every step, tool and LLM call, including token usage, plus a saved record of the exact prompts behind every answer.

Outcomes: Shipped a production-style stack with 103 backend tests, 6 browser tests, Docker images and Kubernetes manifests verified on a local kind cluster. An LLM evaluation harness replays evidence recorded from the live system so only the model varies, applies rule-based checks, and reports pass rates per model, including a scenario that plants a malicious instruction in the logs.

>Technologies Used

LangGraphLangChainFastAPIPostgreSQL + pgvectorOpenTelemetryKubernetesReactTypeScript
// System Architecture Diagram
                  graph TD
    %% RAG Copilot agent workflow (LangGraph)
    Q["Question from on-call engineer"] --> Classify["classify"]

    Classify -- knowledge --> Docs["retrieve_documents"] --> Answer["answer_knowledge"]
    Classify -- investigate --> Runbooks
    Classify -- investigate --> Evidence

    subgraph Gather [Runs in parallel]
        Runbooks["retrieve_runbooks<br/>RAG over pgvector"]
        Evidence["gather_evidence<br/>Prometheus · Loki · Tempo · deployments"]
    end

    Runbooks --> Diagnose["diagnose<br/>structured LLM output"]
    Evidence --> Diagnose
    Diagnose --> Propose["propose_remediation<br/>typed action list"]
    Propose --> Approval{"await_approval<br/>human decision"}
    Approval -- rejected --> Stop["End"]
    Approval -- approved --> Execute["execute_action<br/>least-privilege Kubernetes"]
    Execute --> Verify["verify_outcome<br/>metrics back within targets"]

    subgraph Platform [Platform]
        PG[("PostgreSQL + pgvector<br/>runs, checkpoints, audit trail")]
        OTel["OpenTelemetry<br/>trace per run"]
    end

    Approval -. paused run saved .-> PG
    Verify -. spans and token usage .-> OTel

    classDef step fill:#121212,stroke:#deec56,stroke-width:1px,color:#fff;
    classDef gate fill:#1a1a1a,stroke:#deec56,stroke-width:2px,color:#deec56;
    classDef infra fill:#121212,stroke:#38bdf8,stroke-width:1px,color:#fff;

    class Classify,Docs,Answer,Runbooks,Evidence,Diagnose,Propose,Execute,Verify step;
    class Approval gate;
    class PG,OTel infra;
                
Android & iOS Mobile ApplicationRelease: 2025

Chic Le Frique

High-performance e-commerce mobile application engineered for a premier Shopify store, delivering a fluid mobile retail experience on both Android and iOS.

Role & Contribution:Mobile Application Developer

Engineered the app architecture from ground up, implemented core e-commerce interactions, and integrated Shopify Storefront APIs with secure checkout and catalog caching.

Problem: A premier Shopify e-commerce brand needed a high-performance, native mobile presence to increase customer retention and reduce cart abandonment on both Android and iOS.

Architecture: Engineered a cross-platform React Native application directly integrated with the Shopify Storefront GraphQL API.

Technical Decisions: Utilized Redux/Context for optimized shopping cart state synchronization. Implemented aggressive image caching and pagination to handle large product catalogs seamlessly.

Outcomes: Delivered a fluid, responsive native retail experience with secure checkout, successfully published to major app stores, leading to increased mobile conversions.

>Technologies Used

React NativeShopify Storefront APITypeScriptRedux / ContextREST APIs
// System Architecture Diagram
                  graph TD
    %% Chic Le Frique Architecture
    subgraph Client [Client Side]
        App[React Native Mobile App\nAndroid & iOS]
        Redux[(Redux/Context\nState Sync)]
        Cache[Image & API Caching]
        App --> Redux
        App --> Cache
    end

    subgraph Backend [Backend Infrastructure]
        Shopify[Shopify Storefront API\nGraphQL]
        REST[Custom REST APIs\nNode.js]
    end

    subgraph External [External Services]
        Payment[Payment Gateway]
    end

    App -- GraphQL --> Shopify
    App -- REST --> REST
    Shopify --> Payment

    classDef client fill:#121212,stroke:#deec56,stroke-width:1px,color:#fff;
    classDef backend fill:#1a1a1a,stroke:#38bdf8,stroke-width:1px,color:#fff;
    
    class App,Redux,Cache client;
    class Shopify,REST backend;
                
Government Water Resource Reporting EcosystemRelease: 2023

Amar Nodi (My River)

A nationwide dual-mobile app and web administration platform funded by the Bangladesh government for citizens and field investigators to report, verify, and resolve water resource issues.

Role & Contribution:Full-Stack Developer & Team Lead

Led a 5-engineer team to architect the complete 60+ endpoint backend REST service and developed core native mobile modules.

Problem: The national government lacked a centralized, real-time ecosystem for citizens to report water resource violations (pollution, encroachment) and for field officers to track resolutions.

Architecture: Designed a multi-client ecosystem with two React Native apps (Citizen & Investigator) communicating with a Node.js/Express Backend and a MySQL database deployed on AWS EC2.

Technical Decisions: Implemented geospatial queries using Google Maps API for precise incident mapping.

Outcomes: The platform was successfully completed and delivered to the government.

>Technologies Used

React NativeNode.jsExpress.jsMySQLAWS (EC2)Google Maps API
// System Architecture Diagram
                  graph TD
    %% Amar Nodi Architecture
    subgraph Mobile Apps
        Citizen[Citizen App\nReact Native]
        Investigator[Investigator App\nReact Native]
    end

    subgraph AWS Cloud [AWS Cloud Infrastructure]
        Backend[Node.js / Express Backend\nEC2 Instances]
    end

    subgraph Third Party
        Maps[Google Maps API]
    end

    Citizen -- HTTPS --> Backend
    Investigator -- HTTPS --> Backend
    
    Citizen -- Direct Upload --> Backend
    Investigator -- Direct Upload --> Backend
    
    Citizen -.-> Maps
    Investigator -.-> Maps
                
Academic Schedule Optimization UtilityRelease: 2021

Section Selector UIU

An algorithmic schedule generation and routine planning Android utility created to solve complex trimester timetable conflicts and class overlapping for university students.

Role & Contribution:Solo Developer & Creator

Conceptualized the algorithmic scheduling solver, designed the intuitive UI, and published the mobile application on Google Play for the university student community.

Problem: Students struggled with manual schedule planning, facing overlapping classes and complex trimester prerequisite conflicts during peak registration.

Architecture: A strictly offline, client-side React Native application. Utilized a custom combinatorial backtracking routine engine to evaluate valid, conflict-free schedules locally.

Technical Decisions: Built offline-first to eliminate network latency and server costs during high-traffic registration periods. Adopted a local storage caching strategy for persisting course criteria.

Outcomes: Published on Google Play and organically adopted by the university student community, dramatically reducing schedule planning time from hours to seconds.

>Technologies Used

React NativeJavaScript / TypeScriptCombinatorial Search AlgorithmLocal Storage
// System Architecture Diagram
                  graph TD
    %% Section Selector Architecture
    subgraph Client [Android Application]
        UI[React Native UI]
        Engine[Combinatorial Search Engine\nJS/TS]
        Storage[(Local Storage\nSQLite / Async)]
    end

    UI -- User Criteria --> Engine
    Engine -- Conflict Checks --> Storage
    Storage -- Return Prerequisites --> Engine
    Engine -- Generate Valid Schedules --> UI
                
Full-Stack Web Management PortalRelease: 2020

Attache Admin Portal

A comprehensive web management portal built for an international client to manage servers, stream infrastructure, video assets, and user permissions centrally.

Role & Contribution:Full-Stack Developer

Designed and built the full client-side SPA dashboard in React and engineered the backend REST API in Python Django with role-based permissioning.

Problem: The client required a centralized interface to manage servers, video assets, and multi-tenant access safely, and adding videos to the catalog one by one was slow and manual.

Architecture: Developed a decoupled full-stack platform consisting of a React.js SPA dashboard consuming a scalable Python Django REST API, with a scraping pipeline that crawls YouTube channels using Selenium and BeautifulSoup to add their videos to the catalog automatically.

Technical Decisions: Implemented strict Role-Based Access Control (RBAC) via session-isolated JWTs. Used Selenium to load JavaScript-rendered YouTube channel pages and BeautifulSoup to extract video metadata. Built responsive server-side paginated data tables for large video catalogs.

Outcomes: Successfully delivered a minimal portal that unified server asset management.

>Technologies Used

React.jsDjango (Python)RESTful APIsRole-Based Access ControlTailwind CSSBeautifulSoupSelenium
// System Architecture Diagram
                  graph TD
    %% Attache Admin Portal Architecture
    subgraph Frontend [Client Side]
        ReactSPA[React.js SPA Dashboard]
        Auth[RBAC Auth State]
    end

    subgraph Backend [Server Side]
        Django[Python Django REST API]
        JWT[JWT Authentication Middleware]
    end

    subgraph Ingestion [YouTube Video Ingestion]
        Selenium[Selenium Headless Browser]
        Soup[BeautifulSoup Parser]
    end

    subgraph Infrastructure
        DB[(Primary Database)]
        YouTube[YouTube Channels]
    end

    ReactSPA -- JSON / REST --> JWT
    JWT --> Django
    Django -- Query --> DB
    Django -- Trigger Scrape --> Selenium
    Selenium -- Load Channel Pages --> YouTube
    Selenium -- Rendered HTML --> Soup
    Soup -- Video Metadata --> DB
    Auth -- Token --> ReactSPA
                
JavaFX Connect Four GameRelease: 2020

Four in a Row

A JavaFX-based two-player Connect Four game developed as an Advanced OOP course project. The game provides a graphical 7×7 board, player name configuration, alternating turns, gravity-based piece placement, win detection, turn indicators, and game restart functionality.

Role & Contribution:Java Developer

Designed and implemented the JavaFX game application, including the interactive board UI, player configuration flow, game-state management, turn handling, piece placement, win detection, and restart functionality.

Problem: Implementing a fully interactive Connect Four game requires coordinating a graphical board with persistent game state, alternating player turns, valid gravity-based moves, and reliable detection of winning combinations.

Architecture: The application uses a JavaFX presentation layer defined with FXML and controlled by dedicated menu and game controllers. A separate PlayingGrid class manages the 7×7 integer game matrix, player state, valid column positions, turn switching, restart behavior, and win detection. The main JavaFX application loads the menu scene and transitions to the game scene when a new game is started.

Technical Decisions: Separated game-state logic from the JavaFX controllers by encapsulating board operations in PlayingGrid, used FXML for declarative UI construction, represented player moves in a 7×7 integer matrix, implemented gravity by locating the lowest available cell in a selected column, and dynamically updated JavaFX controls to represent player pieces and game status.

Outcomes: Delivered a functional desktop Connect Four game with a dedicated start menu, configurable player names, randomized starting player, interactive 7×7 board, visual turn indication, four-in-a-row win detection, winner messaging, disabled controls after a win, and restart support.

>Technologies Used

JavaJavaFXFXMLOOPNetBeansApache Ant
// System Architecture Diagram
                  graph TD
      %% Four in a Row Architecture

      subgraph UI["JavaFX Presentation Layer"]
          MenuFXML["Menu Scene<br/>FXML"]
          GameFXML["Game Board<br/>FXML"]
          MenuController["MenuSceneController"]
          GameController["FXMLDocumentController"]
      end

      subgraph GameLogic["Game Logic"]
          Grid["PlayingGrid"]
          Board["7×7 Integer Grid"]
          Turn["Current Player"]
          Move["Gravity-Based Move Handling"]
          Win["Four-in-a-Row Detection"]
      end

      subgraph Application["Application Layer"]
          Main["Four_in_a_row_oop<br/>JavaFX Application"]
          Scene["JavaFX Scene Switching"]
      end

      Main --> MenuFXML
      MenuFXML --> MenuController
      MenuController --> GameFXML
      MenuController --> Scene
      Scene --> GameFXML
      GameFXML --> GameController
      GameController --> Grid
      Grid --> Board
      Grid --> Turn
      Grid --> Move
      Move --> Win
      Win --> GameController
      GameController --> GameFXML

      classDef ui fill:#1a1a1a,stroke:#deec56,stroke-width:1px,color:#fff;
      classDef logic fill:#121212,stroke:#38bdf8,stroke-width:1px,color:#fff;
      classDef app fill:#1a1a1a,stroke:#a78bfa,stroke-width:1px,color:#fff;

      class MenuFXML,GameFXML,MenuController,GameController ui;
      class Grid,Board,Turn,Move,Win logic;
      class Main,Scene app;
                
Movie & TV Metadata Aggregation SystemRelease: 2019

ISP_FTP

A Python/Django-based media catalog and automation system designed to reduce manual work in building a structured movie and TV-series library by crawling remote media directories, extracting titles, and automatically enriching them with IMDb metadata and artwork.

Role & Contribution:Backend Engineer

Built a Django web application around a reusable media-ingestion backend. Implemented recursive parsing of remote media directories, automated poster retrieval, and IMDb integration.

Problem: Building structured media libraries from raw remote directories is highly manual and time-consuming without automated metadata extraction.

Architecture: Remote media directories are parsed via BeautifulSoup/lxml, titles are extracted, enriched via IMDbPY, downloaded via Pillow, and stored in Django ORM with SQLite.

Technical Decisions: Utilized Django ORM and SQLite for structured persistence, decoupled the automated ingestion endpoint from the presentation layer, and implemented robust fallback handlers for missing artwork.

Outcomes: Delivered a fully functional media catalog system with separate modules for movies and TV shows, enabling single-click ingestion from remote media servers.

>Technologies Used

PythonDjango 2.2Django ORMSQLiteIMDbPYBeautifulSouplxmlPillowBootstrap
// System Architecture Diagram
                  graph TD
    %% ISP_FTP Architecture
    subgraph Ingestion [Ingestion Pipeline]
        Crawl[Remote Media Directories]
        Parse[URL/HTML Parser\nBeautifulSoup / lxml]
        Extract[Filename & Title Extraction]
        IMDb[IMDb Metadata Enrichment\nIMDbPY]
        ImageDL[Image Download\nPillow]
    end

    subgraph Storage [Persistence Layer]
        ORM[Django ORM]
        SQLite[(SQLite Database)]
        Media[(Local Media Storage)]
    end

    subgraph Frontend [Web Interface]
        DjangoViews[Django Views & Templates]
        UI[Movie/TV Web Interface\nBootstrap 4]
    end

    Crawl --> Parse
    Parse --> Extract
    Extract --> IMDb
    IMDb --> ImageDL
    ImageDL --> ORM

    ORM --> SQLite
    ORM --> Media

    SQLite --> DjangoViews
    Media --> DjangoViews
    DjangoViews --> UI
    
    classDef pipeline fill:#1a1a1a,stroke:#deec56,stroke-width:1px,color:#fff;
    classDef db fill:#121212,stroke:#38bdf8,stroke-width:1px,color:#fff;
    
    class Crawl,Parse,Extract,IMDb,ImageDL pipeline;
    class SQLite,Media db;