Full-Stack DevelopmentBackend APIsAuthenticationRBACMySQLDockerReactNode.jsExpressNginx

Full-Stack Restaurant Management System

Full-stack restaurant operations platform with JWT auth (stored in cookies), 5-level role-based permissions, and a MySQL-backed backend. Dockerized deployment with React + Node/Express + Nginx.

Overview

A full-stack restaurant management system supporting customer accounts and internal staff operations. Built with a React frontend, Node.js/Express REST API, and a real MySQL database. Implements secure authentication with JWT stored in cookies and role-based access control across five permission levels (customer, employee, admin, manager + one additional internal level). Includes full CRUD workflows across core entities and SQL usage beyond basics (joins/unions, inserts/updates/deletes).

Practice end-to-end web engineering: API design, secure auth, database-backed state, permission boundaries, and reproducible deployment with Docker.

Your Role

What I Built

React frontend with routed views, forms, and role-aware UI behaviors
Express REST API with protected routes and permission checks
JWT authentication stored in cookies + password hashing (bcrypt)
MySQL-backed data layer with CRUD operations and more advanced SQL queries (joins/unions)
Dockerized deployment (frontend served by Nginx; backend + DB orchestrated via Compose)

What I Owned End-to-End

End-to-end full stack integration (React ↔ API ↔ MySQL) including auth and role gating
RBAC implementation for 5 permission levels with route-level enforcement
SQL query implementation covering required operations (create/insert, update, delete, joins/unions)
Deployment workflow using Docker images + env-driven config

Technical Highlights

Architecture Decisions

Client–server architecture: React frontend + Express REST API
MySQL database as system of record for restaurant entities and workflows
JWT stored in cookies for session persistence and protected API access
Docker Compose orchestration; Nginx serves production frontend build

Algorithms / Protocols / Constraints

RBAC checks enforced per route (permission-level gating)
Password hashing via bcrypt; token verification on protected endpoints

Optimization Strategies

Clear separation of concerns: UI, API routing, and database access
Reusable endpoints and modular backend structure
Validation on both client and server to reduce invalid requests

Tech Stack

JavaScriptReactNode.jsExpressMySQLDockerNginx

Results / Learnings

What Worked

Implemented a complete restaurant management app with secure auth + role-based permissions
Connected to a real MySQL database and implemented full CRUD plus joins/unions as part of required operations
Containerized frontend/backend/DB for consistent local setup and deployment-style execution

What I Learned

Auth correctness is mostly about edge cases: cookie handling, token expiry, and route protection consistency
RBAC becomes much easier to maintain when permissions are centralized and enforced at the API boundary
Schema/query choices directly shape feature velocity and complexity

Tradeoffs Considered

Used cookie-stored JWTs for straightforward session handling instead of OAuth or a full identity provider
Prioritized end-to-end correctness and feature completeness over advanced frontend performance optimization
Kept DB constraints pragmatic rather than exhaustively modeling every invariant at the schema layer

← View All Projects

← Raspberry Pi Bare-Metal Systems Programming (AArch64)