Engineering Record
How the systems were engineered.
Index Navigation
01 / Engineering Identity
Technical Center of Gravity.
I am a full-stack software engineer with a Computer Science foundation whose primary technical center of gravity is in backend engineering, APIs, relational databases, and system architecture.
While my deepest professional experience is in the JavaScript and TypeScript ecosystem, my engineering capability is not bounded by a single framework or runtime. I design software systems around underlying engineering principles: transactional consistency, database-enforced Row-Level Security, deterministic state machines, idempotent API workflows, and defensible architectural trade-offs.
Role
Full-Stack SWE
Core Depth
TypeScript / Node
Data & Security
PostgreSQL / RLS
Ownership
End-to-End
02 / Capabilities
What I actually engineer.
Core engineering disciplines backed by verified implementations in production and flagship projects.
Backend & API Engineering
Service Boundaries, Validation, State Transitions & Automation
Structuring server-side systems with explicit boundary contracts, request validation, authentication, state transition enforcement, and scheduled background workers.
- RESTful API design with clean resource routing, status conventions, and middleware pipelines
- Deterministic state machine enforcement governing entity lifecycles and business workflows
- Asynchronous background workers for scheduled reconciliation, notifications, and cleanups
- Centralized business logic ensuring client applications never dictate backend state
Data & Persistence
Relational Modeling, Integrity, Consistency & Access Control
Designing relational data models around real application relationships, consistency guarantees, transactional safety, and database-level security policies.
- Relational schema design with normalized tables, foreign keys, and indexes
- Row-Level Security (RLS) policies enforcing multi-tenant isolation directly at the database layer
- PostgreSQL persistence with Prisma ORM and direct query optimization
- Transactional integrity preventing inventory overselling and orphaned records
Full-Stack Systems
Connecting Client Interfaces to Resilient Services
Building unified multi-client architectures where client SPAs and PWAs communicate cleanly with shared backend services and third-party storage/communication providers.
- Multi-app architectures connecting distinct customer and vendor frontends to shared services
- Resilient session recovery using token headers for persistent guest checkouts
- Cloud storage integration for multipart image upload and secure delivery
- Server Components and SSR execution for fast initial rendering and search visibility
System Architecture
Application Boundaries & Separation of Concerns
Decomposing systems into logical responsibility layers without introducing distributed-system operational overhead before scale requires it.
- Modular backend architecture balancing domain isolation with operational simplicity
- Clear separation of content management, operational records, and asset storage
- Centralized API gateways preventing duplicated domain implementations
- Clean separation between guest browsing, cart state, and order draft lifecycles
Reliability & Invariants
Idempotency, State Invariants & Defensive Engineering
Anticipating network interruptions, duplicate submissions, stock contention, and unverified payment states through defensive software patterns.
- Idempotent draft order submission preventing duplicate records on network retries
- Atomic stock validation ensuring inventory is verified before decrementing
- Self-healing background reconciliation repairing stalled order states
- Automated end-to-end checkout test harness verifying critical path invariants
Security & Authorization
Role Isolation, RLS & Safe Credential Management
Securing application data through defense-in-depth: database-layer authorization, token hashing, input sanitization, and strict secret isolation.
- PostgreSQL RLS policies evaluating JWT claims via custom SQL helper functions
- Zero vendor data cross-contamination enforced at the SQL query level
- Guest order access controlled via secure cryptographic token hashes
- Strict separation of build-time and runtime secrets preventing credential leakage
Delivery & Ownership
Requirements → Architecture → Implementation → Deployment
Taking complete ownership of the engineering lifecycle from problem discovery and architecture definition through deployment, observability, and debugging.
- End-to-end development of production web, mobile, and backend platforms
- Cloud deployment pipelines on Vercel, Render, Railway, and managed database services
- Thorough system documentation and schema alignment guides for maintainability
- Rapid debugging of production incidents, schema migrations, and configuration mismatches
03 / Stack Foundations
Stack foundations & capabilities.
Structured around engineering depth and responsibility rather than an unranked list of keywords.
Languages
Core implementation languages ordered by depth of professional practice.
JavaScript / TypeScript
Primary EcosystemPrimary ecosystem for type-safe backend APIs, server components, and client applications.
SQL
Data LayerRelational data modeling, PostgreSQL schema migrations, indexes, and RLS access policies.
Python
ExpandingApplied ML experimentation, computer vision scripts, and backend development with FastAPI / Django.
Kotlin
MobileNative Android application development, Coroutines, and ViewModel architecture.
C++ · Rust
Working FamiliaritySystems programming, memory management principles, and continued technical exploration.
Backend & APIs
Server-side runtime, frameworks, and API communication standards.
Node.js · Express.js
Modular REST API architecture, middleware pipelines, and controller routing.
NestJS
Enterprise modular backend development with dependency injection.
Next.js App Router
Full-stack server components, API route handlers, and SSR orchestration.
REST APIs
Structured JSON contracts, status conventions, and idempotent endpoints.
FastAPI / Django
Python-based API services, data ingestion, and rapid prototyping.
Data & Persistence
Relational databases, ORMs, and authorization layers.
PostgreSQL
Primary relational database engine with strict integrity, indexing, and foreign keys.
Relational Data Modeling
Entity-relationship design, normalization, constraints, and data lifecycles.
Supabase
Managed PostgreSQL hosting, Auth, and Row-Level Security (RLS) enforcement.
Prisma ORM
Type-safe database client and schema synchronization for PostgreSQL.
Neon PostgreSQL
Serverless PostgreSQL platform for operational record management.
Mobile & Applied ML
On-device processing, mobile SDKs, and external computer vision APIs.
Android SDK 33 · Kotlin
Native Android application development with Material Design UI.
TensorFlow Lite
On-device quantized ML inference (MobileNetV3) for local object recognition.
Imagga Vision API
Cloud-based visual recognition and object tagging service.
Kotlin Coroutines
Non-blocking asynchronous background execution on mobile devices.
Engineering & Delivery
Source control, containerization, hosting platforms, and deployment workflows.
Git & GitHub
Branch workflows, version control, PR reviews, and issue tracking.
Vercel
Frontend SPA, PWA, and Next.js production hosting and edge routing.
Render & Railway
Node.js backend container and web service hosting.
Docker
Containerization of local service dependencies and backend runtimes.
Services & Integrations
Headless content management, media storage, and transactional communication.
Sanity CMS
Headless content lake and embedded studio for editorial website management.
Cloudinary
Secure media storage, image transformations, and proof screenshot uploads.
Resend & Nodemailer
Transactional email delivery for notifications and payment reminders.
OkHttp & Axios
Resilient HTTP clients with interceptors, timeouts, and header injection.
04 / Flagship System 01
Multi-app commerce & relational persistence.
Multi-Application Commerce Platform with 3-Dimensional State Machines and PostgreSQL RLS
System & Problem:A production commerce platform for an eyewear business separating public customer shopping from vendor administration, powered by a shared Node.js/Express API and PostgreSQL database. Allowed the business to run independent customer and vendor workflows without duplicating business logic or introducing the high operational overhead of distributed microservices.
What I Engineered:Sole developer and system architect responsible for the customer SPA, vendor PWA, Express/TypeScript API, PostgreSQL schema, RLS policies, background reconciliation cron jobs, and automated test suite.
What It Proves:I can architect complete multi-role software systems, design normalized relational databases, manage complex lifecycles, and deliver reliable backend workflows.
Two Independent Frontends · Single API Gateway · Relational Persistence
Customer Storefront
Product catalog, CartContext, delivery capture, guest checkout drafts.
Vendor Dashboard
Inventory admin, product CRUD, real-time orders, payment proof review.
Single Source of Truth
Sole boundary between frontends and database. Frontends cannot access PostgreSQL directly.
• JWT Claim Verification & Role-based Access
• 3D State Machine Transitions (Payment/Fulfillment/Stock)
• Draft Order Token Hashing & Rate Limiting
• Multipart Media Upload Interceptor
Relational Database & RLS
Normalized schemas, foreign keys, and Row-Level Security policies for vendor isolation.
Cloudinary & Email Delivery
Direct media asset delivery & Nodemailer hourly reconciliation summaries.
Catalog, cart, guest checkout drafts, Mobile Money payment display.
Role-authenticated inventory CRUD, order board, proof review.
Single Source of Truth
Sole gateway to database. Handles state machines, JWT auth, rate limits, and order hashing.
PostgreSQL & RLS
Vendor-isolated tenant rows and transactional consistency.
Cloudinary & Cron Alerts
Product images CDN and scheduled background reconciliation.
Architectural Accuracy Note on Payment Flow:
There is no third-party automated payment gateway API (no Stripe/MTN API integration). Payment operates via user-directed Mobile Money transaction codes recorded in the order state, verified manually by the vendor before status advancement.
3-Dimensional State Management
Rather than collapsing business workflows into a single generic status column, the backend tracks three orthogonal dimensions to maintain invariants:
Order Lifecycle State
Controls physical order fulfillment. Transitions are strictly validated (e.g., cannot transition from DRAFT directly to DELIVERED). Stock is reserved upon submission.
Payment State
Tracks transaction settlement. Mobile money orders move from PENDING to AWAITING_VERIFICATION upon proof upload, requiring explicit vendor verification to reach VERIFIED.
System Resolution State
Used by automated reconciliation jobs and admin audits to resolve stalled transactions, timeouts, and manual overrides without corrupting lifecycle records.
Reliability & Invariant Enforcement
Idempotent Draft Order Submission
Draft orders are created early during checkout and hashed via `order_token_hash`. If a user refreshes or re-clicks submit, the backend restores the existing active draft instead of creating duplicate orders or double-reserving inventory.
Atomic Stock Validation & Reservation
Before any order moves to an active submission state, the backend compares requested quantities against available stock in PostgreSQL, preventing overselling under concurrent requests.
Automated Reconciliation Cron Jobs
A background job scheduled with `node-cron` runs every 15 minutes to scan orders in intermediate states, while an hourly job scans pending Cash-on-Delivery (COD) orders and dispatches vendor email reminders.
End-to-End Checkout Test Harness
Maintains an automated test suite (`server/test-checkout-flow.js`) that exercises live server endpoints: health checks, single/multi-item draft creation, stock decrements, payment method branching, and failure cancellations.
Security & Row-Level Security (RLS)
Security is enforced at the database layer via PostgreSQL Row-Level Security (RLS) policies. Custom SQL helper functions in the `app` schema extract JWT claims (`user_id`, `role`, `vendor_id`). Anonymous buyers can only read active products (`is_active = true`), customers can only read their own orders via authenticated ID or guest order token hash, and vendors are strictly constrained to records matching their `vendor_id`.
Engineering Retrospective
What Worked: Separating frontends while centralizing backend domain logic provided excellent boundary clarity and allowed fast iteration on the customer UI without breaking vendor rules.
Real Constraint: Direct Mobile Money automated gateway integration was unavailable for local merchant accounts, requiring an asynchronous workflow where users submit USSD transaction screenshots for vendor verification.
What I Would Change: With direct payment gateway credentials, I would replace manual screenshot proof verification with webhook-driven automated settlement (e.g. MTN MoMo API webhooks) to make payment verification instant.
05 / Flagship System 02
Applied computer vision & pragmatic ML.
Android Object Recognition Architecture: Balancing On-Device Inference with Cloud Fallback
System & Problem:A native Android image identification application that combines custom touch bounding-box ROI annotation, quantized on-device MobileNetV3 inference, and cloud-based recognition fallback. Enabled users to capture photos, select specific objects within cluttered scenes using touch bounding boxes, and receive instant classification results across both online and offline environments.
What I Engineered:Primary developer responsible for the Android MVVM architecture, custom Canvas annotation view, bitmap preprocessing pipeline, dual-inference integration, and defensive error fallback.
What It Proves:I can build native mobile systems, handle non-blocking asynchronous concurrency with Coroutines, manage device memory safely, and make pragmatic architectural trade-offs.
Android Client Boundary · Dual Recognition Routes · Fallback Routing
Camera Bitmap & ROI
Raw capture, aspect-ratio scaling (224×224 / 300×300), and interactive Region-of-Interest (ROI) touch selection.
Pre-Inference Normalization:
RGB byte buffer tensor allocation & orientation matrix correction.
TensorFlow Lite Model
Local MobileNet quantized model running on Android NNAPI/GPU delegate with zero network latency.
Imagga Vision API (HTTPS)
Cloud-based categorization returning multi-tag confidence vectors and hierarchical semantic labels.
Visual Annotation
Dynamic bounding box overlay, classification tags, top-3 ranked confidence bars, and fallback status badge.
Offline Resilience:
Network failure gracefully defaults to local prediction without crashing UI.
Interactive Touch ROI
Aspect ratio scaling, bitmap buffer pooling, and touch bounding box selection.
~40ms, offline MobileNet model, instant bounding box.
~350ms over HTTPS, deep semantic classification tags.
Auto Fallback: If on-device TFLite score < 0.65, triggers cloud inference automatically.
Visual Classification Labels
Displays top-ranked predictions, confidence bars, and fallback status without blocking UI thread.
Architectural Boundary & Latency Trade-off:
The on-device TFLite pipeline prioritizes immediate user feedback (zero network dependency) while the Imagga Cloud API path prioritizes classification accuracy. The router decouples the recognition strategy from the UI layer.
Pragmatic ML Scope Trade-Off
Pragmatic ML Scope Pivot
Decision: Adopted Imagga's cloud recognition API for primary classification in the delivered release while maintaining the TensorFlow Lite on-device model as an offline fallback.
Reasoning: A single on-device MobileNetV3 quantized model provided limited class coverage for general open-world objects, and compiling multi-model native pipelines with CMake exceeded the delivery window.
Outcome: Delivered a functional, robust end-to-end user workflow with high classification accuracy without abandoning the local inference research pipeline.
Defensive Recognition Fallback Pipeline
Decision: Implemented a 3-tier classifier hierarchy: Fast Mode (on-device TFLite), Accurate Mode (Imagga Cloud API), and Auto Mode (cloud primary with instant fallback to on-device TFLite upon network failure).
Reasoning: Mobile devices frequently operate in low-bandwidth or offline environments where cloud-only applications crash or freeze.
Outcome: Application maintains 100% operational availability regardless of internet connectivity.
Defensive Engineering & Android Lifecycle
- Multiple classifier initialization retries to prevent app startup crashes if model assets fail to load.
- Kotlin Coroutines for all network and inference operations, preventing UI thread blocking and ANR errors.
- Zero hardcoded credentials: API keys and secrets are loaded from secrets.properties at build time via local.properties.
- Strict memory management releasing large bitmap references after cropping to prevent OutOfMemoryError exceptions.
Engineering Retrospective
What Worked: The bounding-box ROI annotation mechanism dramatically improved recognition accuracy by eliminating noisy background pixels before feeding tensors to the model.
Constraint: Mobile hardware diversity meant raw on-device float32 models caused thermal throttling, necessitating 8-bit quantization (`MobileNet-v3-Large-Quantized.tflite`).
Next Iteration: Implement on-device custom fine-tuned YOLOv8-nano models utilizing the Android NNAPI hardware acceleration delegate for real-time bounding box detection.
06 / Production Web System
Separation of responsibilities in production.
Production Web Architecture with Strict Separation of System Responsibilities
System & Problem:The official live web platform and operational mentorship portal for Acholi Women in Health Foundation, an active healthcare NGO operating in Northern Uganda. United public healthcare storytelling, active NGO program publishing, operational mentorship submissions, secure CV/document uploads, and automated email alerts into a live, production-deployed Next.js platform in active use by the organization.
What I Engineered:Lead developer responsible for the complete production lifecycle: Next.js App Router architecture, Sanity CMS studio integration, Neon PostgreSQL schema, Prisma ORM queries, Cloudinary document storage, and Resend email pipelines.
What It Proves:I understand how to architect, deploy, and maintain live production systems with distinct service boundaries, strict environment configurations, and active organizational users.
Decoupled Architecture · Editorial Lake · Relational Records
Donors & Applicants
Reads health stories, browses NGO initiatives, submits mentorship applications with CVs.
NGO Editors
Accesses embedded Sanity Studio to publish maternal health articles and update leadership registries.
Full-Stack Server Gateway
Separates public SSR page caching from dynamic transactional server actions and file upload handlers.
• Server-Side Rendering (ISR) for speed
• Server Actions for validation & submission
• Multipart document stream handler
Headless Content Lake
Zero-code editorial publishing for NGO staff.
Prisma ORM Relations
Relational mentorship applications & logs.
Secure File Storage
Isolates PDF/CV binaries from database.
Transactional Emails
Instant submission receipts & admin alerts.
Health storytelling & mentorship application forms.
Sanity Studio editorial workflows.
Orchestrator & Server Actions
Routes read requests to cache and write requests to respective backend services.
Editorial Content Lake
Relational Prisma Tables
Encrypted CV Storage
Transactional Email Alerts
Public Editorial Content
Sanity CMS + Embedded Studio
Empowers non-technical organization staff to publish news, maternal health stories, program updates, and leadership registries without touching application code.
Operational Records & Applications
Neon PostgreSQL + Prisma ORM
Stores structured mentorship applications, contact submissions, and newsletter subscriber tables with relational data integrity.
Secure Document Storage
Cloudinary
Handles encrypted document and CV uploads submitted during mentorship applications, isolating binary file storage from database servers.
Transactional Communication
Resend
Automates email delivery, sending submission confirmations to applicants and instant notifications to foundation administrators.
Application Orchestrator
Next.js App Router (TypeScript) on Vercel
Orchestrates server-side rendering, input validation (Zod), API route security, and global edge delivery with zero layout shifts.
07 / Additional Systems
Interactive PWAs & web platforms.
Supporting projects demonstrating stateful client interactions, installable PWAs, and high-density information architecture.
Valentine's Proposal Interactive Platform
An interactive Progressive Web App featuring client-side decision state machine transitions, user-generated unique proposal links via URL hash parameters, persistent responses, and audio-visual touch choreography.
- Deterministic state transitions managing non-linear branching decision paths.
- Dynamic URL parameter parsing allowing users to generate custom proposal links without creating accounts.
- Installable PWA manifest configuration with service worker asset caching for offline resilience.
- Supabase integration persisting user responses with real-time feedback.
Al-Birr Charity Organization
A structured humanitarian portal organizing multiple community programs, field impact reports, and donor conversion paths with privacy-conscious presentation boundaries.
- Modular domain hierarchy isolating program registries, media verification, and donor conversion.
- Privacy-aware presentation architecture for vulnerable community documentation.
- Fast SSR execution and semantic markup optimized for low-bandwidth mobile networks.
Pamoja Outreach Foundation
A lightweight, multi-domain impact platform translating grassroots outreach programs and volunteer ingestion into a high-performance web experience.
- Custom responsive layout architecture delivering zero layout shift across screen sizes.
- Zero-dependency vanilla client implementation maximizing performance and load times on mobile devices.
- Clear visual hierarchy directing visitors toward grassroots volunteering and sponsorship channels.
08 / Decision Records
Architectural decisions & trade-offs.
Senior engineers evaluate technical reasoning. Major system choices are documented as:Problem → Options → Decision → Reasoning → Trade-Off
Modular Backend vs. Premature Microservices
The Problem
The system required separate customer and vendor workflows with distinct security boundaries, but had a small team and bounded domain scale.
Evaluated Options
- •Deploy multiple microservices (Auth service, Order service, Product service, Vendor service)
- •Build a monolithic frontend and backend with no internal boundaries
- •Build separate frontend apps communicating with a single modular Node.js/Express backend (Selected)
Decision & Reasoning
Adopted a modular backend architecture with separate customer and vendor client applications.
Microservices introduce distributed tracing, network failure modes, container orchestration overhead, and multi-service deployment complexity. A modular backend provides clean domain separation without distributed systems overhead.
Trade-Off Accepted
Gained rapid development, unified transactions, and simple deployment; sacrificed independent service-level autoscaling.
Cloud Recognition API Integration vs. Incomplete Local ML
The Problem
Delivering a reliable object recognition app within project deadlines when on-device MobileNetV3 quantized models had limited domain vocabulary.
Evaluated Options
- •Delay launch to compile custom multi-model NDK/CMake native pipelines on-device
- •Ship with on-device model only, accepting poor classification accuracy on diverse objects
- •Integrate Imagga Cloud REST API for high accuracy while retaining on-device TFLite as fallback (Selected)
Decision & Reasoning
Used Imagga API for primary recognition while maintaining on-device TFLite as offline fallback.
Engineering is about shipping functional systems under real constraints. The dual-mode architecture fulfilled user requirements immediately while keeping the research pipeline active.
Trade-Off Accepted
Gained broad classification coverage and high accuracy; introduced network latency and third-party API dependency.
Database-Layer Row-Level Security (RLS) vs. Client Authorization
The Problem
Preventing malicious users or vendors from accessing or modifying unauthorized orders, products, or payment proofs.
Evaluated Options
- •Rely solely on frontend UI hiding and route guards
- •Filter queries inside Express controller handlers only
- •Enforce PostgreSQL Row-Level Security (RLS) policies at the database layer (Selected)
Decision & Reasoning
Implemented PostgreSQL RLS policies in server/db/rls-policies.sql using custom SQL helper functions in the app schema.
Frontend checks are trivially bypassed. Enforcing isolation at the database layer guarantees that even if an API endpoint has a logic bug, the SQL query cannot return unauthorized rows.
Trade-Off Accepted
Gained ironclad multi-tenant data isolation; required careful schema alignment and custom SQL migration management.
Strict Multi-Service Separation of Concerns
The Problem
Handling editable marketing content, sensitive mentorship applications, large PDF document uploads, and transactional notifications in one platform.
Evaluated Options
- •Store all data and uploaded PDF binaries directly in a single PostgreSQL database
- •Use an all-in-one proprietary CMS for database, forms, and assets
- •Separate duties: Sanity (content), Neon PostgreSQL (records), Cloudinary (files), Resend (emails) (Selected)
Decision & Reasoning
Decoupled responsibilities across best-in-class specialized managed services orchestrated by Next.js.
Databases degrade when bloated with binary PDFs. Content editors should not touch production database tables. Decoupling ensures each service handles its optimal workload.
Trade-Off Accepted
Gained reliability, performance, and clear ownership; required managing multiple API credentials and integration points.
Asynchronous Background Reconciliation vs. Synchronous Request Blocking
The Problem
Handling Cash-on-Delivery (COD) reconciliation and orphaned draft sessions without blocking HTTP request threads.
Evaluated Options
- •Execute reconciliation scans inside user checkout request handlers
- •Rely on manual administrator database inspection
- •Run automated background cron jobs for reconciliation and reminders (Selected)
Decision & Reasoning
Implemented dedicated background jobs in server/src/jobs running on 15-minute and hourly schedules.
Checkout requests must remain fast and responsive. Background workers isolate system maintenance tasks from the critical user transaction path.
Trade-Off Accepted
Gained fast user response times and automated healing; required idempotent job design to avoid double-processing orders.
09 / Production Invariants
Reliability & production invariants.
Defensive engineering practices implemented across codebases to ensure stability beyond the happy path:
Defensive Validation
Validate all data at the entry boundary before executing business logic.
Server-side schema validation (Zod, Express middleware, Kotlin data classes) rejecting malformed payloads before touching the database or ML models.
State Machine Invariants
Prevent invalid state transitions and illegal business states.
Deterministic state transitions enforced by controller state machines. Transitions from DRAFT directly to DELIVERED or double-verifications are blocked.
Idempotent Operations
Ensure repeated requests produce identical, non-corrupting results.
Hashing checkout tokens (`order_token_hash`) to reuse existing draft sessions rather than creating duplicate orders upon network retries.
Database Integrity & Access Control
Enforce data isolation and referential integrity at the persistence layer.
PostgreSQL foreign keys, NOT NULL constraints, normalized schemas, and Row-Level Security (RLS) policies.
Automated Failure Recovery
Design systems to recover automatically from network timeouts and third-party drops.
Dual-mode fallback pipelines on mobile and background reconciliation cron jobs that advance or timeout stuck orders.
End-to-End Automated Testing
Validate critical business flows against real backend endpoints.
Automated test harnesses exercising complete API lifecycles: draft creation, stock decrements, payment variations, and cancellation paths.
10 / Public Activity
Public commit & contribution record.
An authentic public record of ongoing development and engineering iterations behind the projects.
Verified Public Activity
GitHub Contribution Activity
Past 12 Months
...
11 / Repositories
Source code & public repositories.
Inspectable repository references and codebase foundations available on GitHub.
Oakley Glasses Store
Hussein-dev256/Oakley-Glasses-Store
Multi-app e-commerce system featuring React/Vite storefront, vendor PWA, Node.js/Express API, PostgreSQL RLS, 3-dimensional state machines, and end-to-end checkout test harness.
ObjectID Android App
Hussein-dev256/ROI-Based-Image-ID-Android-App
Android application combining camera/gallery workflows, custom bounding-box ROI annotation, quantized MobileNetV3 TensorFlow Lite on-device inference, and Imagga Cloud REST API fallback.
AWIHF Healthcare Platform
Hussein-dev256/AWIHF-Platform
Next.js App Router portal with strict separation of concerns: Sanity CMS, Neon PostgreSQL + Prisma ORM, Cloudinary document storage, and Resend transactional email.
Valentine's Proposal PWA
Hussein-dev256/Valentines-Proposal-PWA
Interactive Progressive Web App featuring client-side decision state machine transitions, URL-encoded parameter sharing, and Supabase persistence.