3. 📊 Live Telemetry & Observability Log Tail

• Request Auditor Middleware: Incepts all incoming client-side REST calls, calculating precise execution latencies in milliseconds.
• Telemetry Endpoints:
  • GET /api/v1/health - Health metrics, Node process runtimes, and exact RAM footprint logs.
  • GET /api/v1/stats - Compiles success rates, error counts, response latencies, and transaction metrics.
• Visual Log Viewer: Displays a live scrolling console of access requests directly in the client dashboard, color-coded by HTTP methods and status responses.

4. 📖 Interactive Swagger-Style Explorer

• Interactive Sandbox: Evaluators can view detailed request structures and schemas, tweak input parameters/JSON payloads, and dispatch live HTTP calls.
• Auto-Authorization Hooks: Successfully executing a Register or Login call automatically captures the returned JWT, storing it globally to authorize subsequent protected endpoints without manual token swapping.

🛠️ Tech Stack & Architecture

• Backend Platform: Express v4.x (Node.js engine)
• Compilation Tooling: tsx (for direct TS execution in dev), esbuild (to bundle CJS for server production), Vite v6
• Frontend Client: React v19, Tailwind CSS v4, Lucide Lucent vector designs, custom CSS frame motions.
• Local Persistence: Atomic JSON File database ./data/db.json with safety caches and pre-seeded developer credentials.

🔌 API Endpoint Specifications

🔐 Authentication

📋 Tasks (Secondary Entity)

📦 Getting Started & Installation

To run this project locally, ensure you have Node.js (v18+) installed.

1. Install Dependencies:

   npm install
   

2. Boot Development Server:

   npm run dev
   

   The application dev environment is mounted at http://localhost:3000 with HMR and hot TypeScript compiling.

3. Build Production Assets:

   npm run build
   

   Compiles static HTML/React bundles and packages the Express backend into a standalone file dist/server.cjs via esbuild.

4. Launch Standalone Production Server:

   npm run start
   

📈 Scalability Note & Production Blueprint

A brief note on how we transition this lightweight sandboxed architecture into a system supporting millions of active connections:

1. Distributed API Clusters: Wrap Node services in lightweight Docker images. Deploy to container schedulers (Kubernetes or Google Cloud Run) utilizing horizontal pod autoscalers (HPA) to scale up when CPU utilization exceeds 70%.
2. Session Security (HttpOnly Access & Redis): Transition from local state storage to dual-token models. Store JWT Refresh keys inside secure, HttpOnly, SameSite=Strict cookies. Maintain a globally distributed Redis cluster to manage token blacklists and active user-session caches.
3. Primary-Replica DB Topologies: Migrate the local storage file to PostgreSQL. Route database mutation operations (inserts, updates, deletes) to a primary PostgreSQL instance, and split the read load by distributing GET queries across read-only Postgres replicas.
4. Caching Strategy (Lazy Loading Cache-Aside): Implement Redis caching for database entities (like tasks lists). When requests are received, attempt to satisfy the query from the cache first; on a miss, query PostgreSQL and update the cache with an appropriate TTL (e.g., 5 minutes) to save intensive database operations.
5. Connection Management: Introduce PgBouncer to pool database connections, preventing connection exhaustion under heavy load spikes.