// all projects

Project Showcase

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

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 Flask with role-based permissioning.

Problem: The client required a centralized orchestration interface to monitor global streaming infrastructure, video transcoding assets, and multi-tenant access safely.

Architecture: Developed a decoupled full-stack platform consisting of a React.js SPA dashboard consuming a scalable Python Flask REST API.

Technical Decisions: Implemented strict Role-Based Access Control (RBAC) via session-isolated JWTs. Built responsive server-side paginated data tables for high-volume logs.

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

Technologies Used

React.jsFlask (Python)RESTful APIsRole-Based Access ControlTailwind CSS
// 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]
        Flask[Python Flask REST API]
        JWT[JWT Authentication Middleware]
    end

    subgraph Infrastructure
        DB[(Primary Database)]
        Video[Video Transcoding Engine]
        Servers[Server Telemetry Agent]
    end

    ReactSPA -- JSON / REST --> JWT
    JWT --> Flask
    Flask -- Query --> DB
    Flask -- Control --> Video
    Servers -- Logs / Metrics --> Flask
    Auth -- Token --> ReactSPA
                
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;