LLM-Coder

Made the LLm PRactice Platform and coder

Comment

Low-Level Design (LLD) Practice & Evaluation Platform

A full-stack, self-serve platform for practicing Low-Level Design (Object-Oriented Design / Machine Coding) with automated, rubric-based AI evaluation powered by Google Gemini and persistent cloud storage on MongoDB Atlas.

1. Overview

While Data Structures & Algorithms (DSA) have platforms like LeetCode with automated input/output test suites, Low-Level Design has historically lacked a repeatable self-evaluation loop. Learners write architectural designs with multiple classes, interfaces, and patterns, but have no way to objectively assess whether their design meets SOLID principles, handles edge cases, or avoids tight coupling.

This platform provides:

  • Curated Problem Library: 5 realistic, industry-calibrated LLD problems.
  • Asynchronous Evaluation Engine: Automated, deep architectural critique powered by Google Gemini.
  • Fixed 8-Dimension Rubric: Consistent, objective scoring (1–5 scale) with evidence, concerns, and actionable suggestions.
  • Persistent Storage: MongoDB Atlas cloud integration with an automatic zero-downtime in-memory fallback.
  • Attempt History & Longitudinal Tracking: Compare iterations across attempts to observe measurable architectural improvement.

2. Architecture & Tech Stack

┌────────────────────────────────────────────────────────┐
│              FRONTEND: React 19 + Vite                 │
│  - Tailwind CSS + Lucide Icons                         │
│  - Problem Catalog, Workspace, Live Poller, History    │
└───────────────────────────┬────────────────────────────┘
                            │ REST API (/api/*)
                            v
┌────────────────────────────────────────────────────────┐
│             BACKEND: Node.js / Express                 │
│  - Domain Controllers (Problems, Attempts, Evaluations)│
│  - Dual-Mode Storage (MongoDB Atlas + In-Memory Store) │
│  - Multi-Tier Evaluator (Gemini 3.8 Flash + Fallbacks) │
└────────────────────────────────────────────────────────┘
  • Frontend: React 19, TypeScript, Vite, Tailwind CSS, Motion, Lucide React
  • Backend: Node.js, Express, TypeScript (tsx / esbuild)
  • Database: MongoDB Atlas (native official mongodb driver v7.6) with automatic in-memory fallback
  • AI Engine: Google Gemini (@google/genai SDK v2.4) using structured JSON schema output

3. Environment Variables

Create a .env file in the root directory (refer to .env.example):

# Required for AI evaluation
GEMINI_API_KEY=your_gemini_api_key_here

# Optional: MongoDB Atlas connection string (falls back to in-memory store if not provided)
MONGODB_URI=mongodb+srv://<username>:<password>@<cluster-url>/?retryWrites=true&w=majority
MONGODB_DB_NAME=lld_practice

Note on MongoDB Atlas: If MONGODB_URI is omitted or temporarily unreachable, the platform automatically runs using an in-memory document store. You can test and monitor connection health via the Storage badge in the app header or via POST /api/storage-status/reconnect.

4. Getting Started & Running Locally

Prerequisites

  • Node.js v20+ or v22+
  • npm v10+

Installation

npm install

Running the Development Server

npm run dev

The application will start on http://localhost:3000.

Building & Running for Production

# Build Vite client and bundle CommonJS server
npm run build

# Start production server
npm start

5. Running Tests

The test suite validates domain logic, state machine transitions, and edge cases using Node's native test runner (node:test via tsx):

npm test

Test Coverage Includes:

  1. Domain Unit Tests (tests/unit/courseManagement.test.ts):
    • Enrollment progress percentage calculation.
    • Zero-lesson courses (safe divide-by-zero handling).
    • Mandatory lesson completion rules.
    • Course.publish() validation (rejects zero-module and zero-lesson courses).
  2. Integration Tests (tests/integration/evaluationFlow.test.ts):
    • Full state machine transition: InProgress → Submitted → Evaluating → Completed.
    • Error transition: Evaluating → Failed with diagnostic error message.
  3. Edge Case Tests (tests/edge-cases/edgeCases.test.ts):
    • Duplicate enrollment prevention.
    • Duplicate submission retry semantics (in-place re-evaluation without duplicate submission records).
    • Independent attempt tracking for repeated problem practice.

6. The 8-Dimension Evaluation Rubric

Every submission is evaluated against eight standard software engineering dimensions:

Dimension Description
1. Requirement understanding Did the design account for all stated functional requirements and constraints?
2. Class responsibilities (SRP) Are responsibilities separated cleanly without bloated "god objects"?
3. Coupling / cohesion Are modules cohesive with minimal cross-domain coupling?
4. Encapsulation & interface design Are internal states private? Are public APIs clean and intuitive?
5. Abstraction & design patterns Are design patterns (State, Strategy, Factory, Observer) applied appropriately?
6. Extensibility Can the architecture accommodate future requirements without major rewrites?
7. Edge case handling Are validation guards, empty collections, and concurrency considerations present?
8. Explanation & reasoning Is the architectural trade-off reasoning clear and articulate?

7. API Reference

Endpoint Method Description
/api/problems GET Lists all curated design problems
/api/problems/:id GET Fetches details and requirements for a specific problem
/api/attempts POST Starts a new practice attempt ({ problemId, userId })
/api/attempts/:id GET Retrieves attempt metadata and submissions
/api/attempts/user/:userId GET Retrieves all historical attempts for a given user
/api/submissions POST Submits solution code and launches async evaluation
/api/evaluations/:id GET Polls current evaluation status and retrieves completed rubric
/api/evaluations/:id/retry POST Retries a failed evaluation in-place
/api/storage-status GET Returns storage diagnostics (engine, connection status, error tips)
/api/storage-status/reconnect POST Forces an on-demand reconnection test to MongoDB Atlas

8. Known Limitations & Roadmap

  • Single Text/Code Input Modality: Submissions are currently text-based (code, interfaces, or structured schemas). Visual diagramming (e.g. interactive UML canvases) is planned via on-the-fly Mermaid.js rendering.
  • Single AI Evaluator Engine: The system currently relies on a single model evaluation pipeline with multi-model fallback. Multi-agent consensus (e.g. Staff Architect vs. Security Reviewer) is slated for future releases.
  • Human Mentorship Integration: Peer review and mentor commentary features are under design for the post-MVP roadmap.

9. Deliverables & Documentation

Share this project:

Updates