A focused DSA revision platform that turns inconsistent interview preparation into structured, competitive practice.
Students preparing for coding interviews often fall into a familiar trap: they keep solving new problems, but rarely revisit the ones they already solved. That makes learning feel like a checklist instead of a mastery process. As a result, problem-solving patterns fade, confidence drops, and interview preparation becomes unpredictable.
LeetLab solves the painful gap between learning and retention by making DSA revision intentional, repeatable, and social.
In school, the most effective study routine was never just reading new material. It was weekly or bi-weekly revision tests that forced us to review old chapters, compare progress, and compete with friends. That structure kept momentum, reduced forgetfulness, and made learning much more engaging.
I wanted that same cadence for coding interview preparation. Instead of endless new questions, I needed a way to revisit solved problems, create revision contests, and keep the process social. That’s why I built LeetLab.
LeetLab helps learners turn DSA revision into a structured workflow:
- Create a custom contest from previously solved problems or chosen topics.
- Run the contest in real-time for yourself or with friends.
- Track performance with leaderboards and contest analytics.
- Discuss problems in TalkTown through private and group chat.
This is not just another practice platform. It is a revision engine that aligns with the real behavior of interview prep: solve, revise, compete, discuss.
LeetLab is built for:
- Students preparing for coding interviews
- Competitive programmers who want structured revision
- DSA learners who need repeatable practice
- Study groups that want group contests and discussion
- Friends practicing together with shared goals
LeetLab lets users build contests from their own question set or selected topics. This solves the core pain point of unstructured revision by making practice intentional.
How it Works:
- Create & Customize: The host sets the contest title, selects problem collections or specific topics, chooses visibility (Public or Private), and sets a custom duration.
-
Unique Entry Code: Upon launching, a unique Contest Code is generated for the lobby. The host can share this code with friends or study group members.
-
Join via Code: Participants simply enter the Contest Code in the Join a Contest arena to enter the pre-contest lobby.
- Waiting Lobby & Live Start: Participants gather in the lobby to view contest rules, duration, and participant lists. Once everyone is ready, the host starts the contest, triggering a synchronized live coding session where users solve and submit problems in real-time.
Users can participate in contests live, which brings accountability and urgency to revision. This feature exists because practice is more effective when it feels like a real challenge, not a passive exercise.
Leaderboards surface progress and promote healthy competition. They solve the problem of motivation loss by showing users where they stand and encouraging consistent effort.
TalkTown is the conversation layer for LeetLab. It solves the isolation of solo prep by giving users a place to discuss problems, compare strategies, and coordinate contests.
Key Features & Functionality:
- User Discovery & Search: Users can search for anyone on LeetLab, view peer profiles, and connect with other learners.
- Direct Messaging (Private Chats): Enables one-on-one communication between peers to discuss specific coding problems, share strategies, or coordinate study sessions.
- Group Chats Users can create group chats for study circles or contest teams. Group members can collaborate, discuss problem approaches, and share resources.
- Group & Admin Controls: Group admins have full management control, including the ability to delete groups when needed, while participants can freely leave a group whenever they choose.
A search feature helps users find peers with similar goals. This solves the problem of limited collaboration by making it easier to connect with other learners.
Secure onboarding, profile management, and role-based access ensure that users can safely manage contests, chat, and revision content.
Contest analytics turn practice into insight. Users get feedback on performance trends, not just raw problem counts.
A typical user journey on LeetLab:
- A user signs up and completes their profile.
- They create a revision contest using selected problems and a time limit.
- They invite friends or join a private contest.
- They participate in the contest in real time.
- They view the leaderboard to compare results.
- They discuss approaches in TalkTown after the contest.
- They track progress over time and repeat the cycle.
- Frontend: React, Vite, Tailwind CSS, React Router, React Query
- Backend: Node.js, Express, Socket.IO, JWT authentication
- Database: MongoDB
- Real-Time Layer: Socket.IO for live contest and chat updates
- Deployment-ready: API-driven architecture with clear frontend/backend separation
I designed, built, and deployed LeetLab end to end:
- Developed the frontend experience in React
- Built the backend API with Node.js and Express
- Designed database models and relationships in MongoDB
- Implemented authentication, authorization, and session flows
- Built real-time contest and chat systems with Socket.IO
- Defined the product workflow and feature priorities
- Maintained a user-first approach across every feature
- Designing real-time contest workflows that stay consistent under live updates
- Managing Socket.IO connections for contest state and chat delivery
- Building a scalable contest model without making the system overly complex
- Ensuring chat and contest data remained synchronized
- Keeping feature design purposeful instead of adding functionality for its own sake
- How a full-stack DSA product is architected end-to-end
- Real-time application design for contest and chat experiences
- Product-driven feature prioritization for learner retention
- The importance of user workflows over feature count
- How backend and frontend need to align on API contracts and state management
- Move real-time contest coordination to a microservice pattern
- Introduce Redis for caching and pub/sub support
- Add event-driven contest analytics pipelines
- Implement push notifications for contest invites and chat updates
- Build stronger monitoring and observability around real-time state
| Planned Improvement | Why it matters |
|---|---|
| Persistent contest rooms | Keep session state when users reconnect |
| Notifications | Increase engagement and reactivation |
| Advanced analytics | Turn contest history into smarter study plans |
| Mobile-friendly UI | Increase accessibility for learners on the go |
| Peer review workflows | Enable collaborative problem feedback |
Screenshots are placeholders. Replace these with actual product visuals.
git clone https://github.com/Uzmaa7/LeetLab.git
cd LeetLabcd Backend
npm install
cp .env
npm run devcd ../Frontend
npm install
npm run devOpen the app in your browser at the frontend development URL.
Create .env files with the following values.
PORT=5000
MONGODB_URI=mongodb://localhost:27017/leetlab
ACCESS_TOKEN_SECRET=your_access_secret
REFRESH_TOKEN_SECRET=your_refresh_secret
JWT_SECRET=your_jwt_secret
CLOUDINARY_CLOUD_NAME=your_cloud_name
CLOUDINARY_API_KEY=your_cloudinary_key
CLOUDINARY_API_SECRET=your_cloudinary_secret
JUDGE0_API_HOST=https://judge0-ce.p.rapidapi.com
JUDGE0_API_KEY=your_judge0_key
FRONTEND_URL=http://localhost:5173VITE_API_BASE_URL=http://localhost:5000/api/v1- Backend API Documentation - Complete API reference
- Backend README - Detailed backend setup and architecture
- Frontend README - Frontend development guide
The backend exposes the following core API groups:
| Area | Base Path | Purpose |
|---|---|---|
| Authentication | /api/v1/auth |
User signup, login, token refresh, avatar updates |
| Problems | /api/v1/problems |
Problem creation, retrieval, and admin management |
| Execution | /api/v1/execute-code |
Run code, judge test cases, track submissions |
| Submissions | /api/v1/submission |
User submission history and counts |
| Lists | /api/v1/list |
Problem playlists and custom learning lists |
| Contests | /api/v1/contest |
Custom contests, contest lifecycle, analytics |
| Chat | /api/v1/chat |
TalkTown private/group messaging |
| Friends | /api/v1/friend |
Discover users, send and accept requests |
Contributions are welcome. Please follow these guidelines:
- Open an issue before building a major feature.
- Follow existing code style and API conventions.
- Keep features aligned with the problem of structured DSA revision.
- Submit pull requests with a clear summary and tests if applicable.
This project is licensed under the ISC License.
LeetLab/
├── Backend/ # Node.js / Express API, Socket.IO, MongoDB models
├── Frontend/ # React application, Vite, Tailwind
├── README.md # Product-focused project README