A premium, full-stack DSA revision platform with spaced repetition, pattern recognition, and comprehensive Low-Level Design learning
- Overview
- Features
- Tech Stack
- Architecture
- Project Structure
- Getting Started
- API Documentation
- Database Schema
- Deployment
- Screenshots
- Contributing
- License
FAANG Forge is an intelligent DSA interview preparation platform designed to help developers master coding interviews through:
- Spaced Repetition: Scientifically-proven scheduling algorithm for long-term retention
- Pattern Recognition: Automatic categorization of 14+ common DSA patterns
- Company-Specific Practice: 2892+ problems from 20+ FAANG & top-tier companies
- Comprehensive LLD: In-depth Low-Level Design content with real-world case studies
- Smart Analytics: Visual insights into your preparation journey
Built with a premium glassmorphic UI and enterprise-grade architecture, FAANG Forge transforms how developers prepare for technical interviews.
Based on the Ebbinghaus Forgetting Curve, our algorithm schedules optimal review times:
Day 1 → First Revision
Day 3 → Second Revision
Day 7 → Third Revision
Day 14 → Fourth Revision
Day 30 → Fifth Revision
Day 60 → Sixth Revision
Day 90 → Final Consolidation
How it works:
- When you mark a problem as "Revised", the system calculates the next optimal review date
- Problems appear in your "Upcoming Reminders" based on this schedule
- Consistent revision moves problems to longer intervals (strength building)
- Missing a revision resets the interval (retention recovery)
The system automatically tags problems with 14+ common DSA patterns:
| Pattern | Keywords | Common Problems |
|---|---|---|
| Two Pointers | "pair", "palindrome", "sorted" | Two Sum, Container With Water |
| Sliding Window | "substring", "contiguous", "window" | Longest Substring, Max Sum Subarray |
| Binary Search | "sorted", "rotated", "find" | Search in Rotated Array |
| BFS/DFS | "path", "level", "traverse" | Word Ladder, Number of Islands |
| Dynamic Programming | "maximum", "minimum", "ways" | Climbing Stairs, Coin Change |
| Backtracking | "permutation", "combination", "subset" | N-Queens, Subsets |
// Automatic problem fetching
const fetchProblemDetails = async (leetcodeUrl) => {
// Extract problem slug from URL
// Query LeetCode GraphQL API
// Return: title, description, examples, constraints
};The gold standard for FAANG preparation, covering:
- Arrays & Hashing (9 problems)
- Two Pointers (5 problems)
- Sliding Window (6 problems)
- Stack (7 problems)
- Binary Search (7 problems)
- Linked List (11 problems)
- Trees (15 problems)
- Heap/Priority Queue (7 problems)
- Backtracking (9 problems)
- Tries (3 problems)
- Graphs (13 problems)
- Advanced Graphs (6 problems)
- 1-D Dynamic Programming (12 problems)
- 2-D Dynamic Programming (11 problems)
- Greedy (8 problems)
- Intervals (6 problems)
- Math & Geometry (8 problems)
- Bit Manipulation (7 problems)
Complete A2Z roadmap covering:
- Basics → Arrays → Strings → Recursion → Backtracking
- Binary Search → Linked List → Stacks & Queues
- Trees → Graphs → Dynamic Programming
Extended collection beyond Blind 75:
- Additional medium/hard problems by pattern
- Interview favorites from top companies
- Edge cases and variations
Famous sheet for Indian placement season:
- Arrays, Matrix, Strings, Searching & Sorting
- Linked List, Binary Trees, BST, Heaps
- Graphs, Stack & Queues, DP, Backtracking
Your personalized collection with:
- Drag-and-Drop Reordering: Prioritize problems you want to focus on
- Pattern Sections: Organize by DSA pattern
- Progress Tracking: Mark problems as complete
- Notes Integration: Add personal notes to each problem
| Metric | Description | Visualization |
|---|---|---|
| Total Problems | All problems in your list | Counter card |
| Solved | Problems marked as complete | Counter with percentage |
| Current Streak | Consecutive days with revisions | Flame icon + counter |
| Active Reminders | Problems due for review | Clock icon + counter |
Weekly Activity Chart: Bar chart showing problems revised per day
Mon: ████ (8)
Tue: ██ (4)
Wed: ██████ (12)
Thu: ███ (6)
Fri: ███████ (14)
Sat: █ (2)
Sun: ████ (8)
Difficulty Breakdown: Pie chart with Easy (Green), Medium (Yellow), Hard (Red)
Topic Distribution: Bar chart of problems per data structure
| Tier | Companies | Total Problems |
|---|---|---|
| FAANG | Google, Amazon, Meta, Apple, Netflix, Microsoft | 4,200+ |
| Top Tier | Uber, Airbnb, LinkedIn, Twitter, Salesforce | 2,100+ |
| Fintech | Goldman Sachs, Bloomberg, DE Shaw, Citadel | 1,400+ |
- Company Search: Find any company instantly
- Problem Filtering: Filter by difficulty within each company
- Quick Import: One-click add to your personal list
- Tag Badges: FAANG (gold) vs Top Tier (silver) indicators
| # | Chapter | Topics Covered |
|---|---|---|
| 1 | Introduction | OS goals, types, architecture |
| 2 | Process Management | Process states, PCB, context switching |
| 3 | CPU Scheduling | FCFS, SJF, RR, Priority, MLFQ |
| 4 | Synchronization | Race conditions, mutex, semaphores |
| 5 | Deadlocks | Prevention, avoidance, detection |
| 6 | Memory Management | Paging, segmentation, virtual memory |
| 7 | Virtual Memory | Page replacement, thrashing |
| 8 | Disk Management | Scheduling algorithms, RAID |
- Relational Model, SQL, Normalization
- Transactions, ACID, Concurrency Control
- Indexing, Query Optimization
- OSI Model, TCP/IP, HTTP/HTTPS
- Routing Protocols, DNS, Load Balancing
- Performance vs Scalability
- CAP Theorem, Consistency Patterns
- Load Balancers, CDN, Caching
- Database Sharding, Replication
- Message Queues, Microservices
| Chapter | Topic |
|---|---|
| 1 | Introduction to LLD |
| 2-6 | SOLID Principles (SRP, OCP, LSP, ISP, DIP) |
| 7-15 | GRASP Principles |
| 13 | Case Study: Parking Lot System |
| 14 | Case Study: Library Management |
We follow a Glassmorphic Dark Theme with:
/* Core design tokens */
--glass-bg: rgba(255, 255, 255, 0.05);
--glass-border: rgba(255, 255, 255, 0.1);
--blur: backdrop-blur(10px);
--gradient-accent: linear-gradient(135deg, #6366f1, #8b5cf6);- Staggered Entry: Cards appear sequentially (100ms delay)
- Spring Physics: Natural, bouncy hover effects
- Exit Animations: Smooth fade-out when removing elements
- Keyboard navigation support
- Screen reader friendly labels
- Color contrast ratios > 4.5:1
- Focus indicators on interactive elements
We chose the MERN stack (MongoDB, Express.js, React, Node.js) for several strategic reasons:
| Factor | Benefit |
|---|---|
| JavaScript Everywhere | Single language across frontend and backend reduces context switching |
| JSON Native | MongoDB stores JSON-like documents, React uses JSON, seamless data flow |
| NPM Ecosystem | Access to millions of packages for rapid development |
| Real-time Capable | Node.js event-driven model supports future real-time features |
| Industry Standard | MERN skills are highly demanded in FAANG interviews |
Why React over Vue/Angular?
├── Component-based architecture for reusability
├── Virtual DOM for optimal performance
├── Largest ecosystem and community support
├── Hooks API for cleaner state management
└── Easy integration with other libraries
Key Features Used:
useState,useEffect,useContexthooks- Custom hooks for API calls and authentication
- React.memo for performance optimization
- Suspense for code splitting
- Nested Routes: Clean URL structure (
/problems/:id) - Protected Routes: Authentication-based access control
- useNavigate: Programmatic navigation after form submissions
- useLocation: Access current URL params for deep linking
// Example: Staggered card animations
const containerVariants = {
hidden: { opacity: 0 },
visible: {
opacity: 1,
transition: { staggerChildren: 0.1 }
}
};Why Framer Motion?
- Declarative animations with React integration
- Physics-based spring animations
- AnimatePresence for exit animations
- Layout animations for smooth transitions
Why Tailwind over CSS-in-JS or Sass?
| Approach | Tailwind Advantage |
|---|---|
| Traditional CSS | No naming conflicts, no separate files |
| CSS Modules | Faster development with utility classes |
| Styled Components | Smaller bundle size, no runtime overhead |
Custom Extensions:
- Glassmorphic card effects with
backdrop-blur - Custom color palette for dark mode
- Responsive breakpoints for mobile-first design
- Built specifically for React (not a wrapper)
- Composable chart components
- Responsive container support
- Smooth animations out of the box
Used for:
- Weekly activity line charts
- Difficulty distribution pie charts
- Topic breakdown bar charts
- Lightweight alternative to react-beautiful-dnd
- Accessibility built-in (keyboard support)
- Smooth animations during drag
- Sortable lists for problem reordering
Why Node.js?
├── Non-blocking I/O for handling concurrent requests
├── Same language as frontend (JavaScript)
├── Excellent for I/O-heavy operations (database, API calls)
├── NPM package ecosystem
└── Easy deployment on modern platforms
Middleware Architecture:
// Request Flow
Request → cors() → json() → authenticate() → Route Handler → ResponseKey Middleware Used:
express.json()- Parse JSON bodiescors- Cross-Origin Resource Sharing- Custom
authenticate- JWT verification - Error handling middleware - Centralized error responses
Why NoSQL over SQL?
| Factor | MongoDB Advantage |
|---|---|
| Schema Flexibility | Problems can have varying fields (hints, companies, patterns) |
| JSON Storage | Direct mapping to JavaScript objects |
| Horizontal Scaling | Easy sharding for future growth |
| Aggregation Pipeline | Powerful analytics queries |
| Document Relationships | Embedded documents for related data |
Collections Structure:
faang-forge-db/
├── users # User accounts and preferences
├── problems # User's personal problem list
├── companyproblems # Shared company-tagged problems (7700+)
├── problemlists # Curated sheets (NeetCode, Striver, etc.)
├── revisions # Revision history for spaced repetition
└── patterns # DSA pattern definitions
// Schema with validation, virtuals, and middleware
const problemSchema = new Schema({
title: { type: String, required: true, maxlength: 200 },
difficulty: { type: String, enum: ['Easy', 'Medium', 'Hard'] },
patterns: [{ type: String }], // Array of pattern tags
next_reminder_date: Date, // Spaced repetition
revision_count: { type: Number, default: 0 }
}, { timestamps: true });Features Used:
- Schema validation
- Pre/post hooks for password hashing
- Virtual properties
- Population for references
- Aggregation pipelines
Authentication Flow:
1. User logs in with email/password
2. Server validates credentials
3. Server generates JWT with userId
4. Client stores JWT in localStorage
5. Client sends JWT in Authorization header
6. Server middleware verifies JWT on protected routes
Token Structure:
{
userId: "ObjectId",
email: "user@example.com",
iat: 1234567890,
exp: 1234567890 + 7 days
}- Salted hashing (prevents rainbow table attacks)
- Configurable work factor (10 rounds)
- Async operations (non-blocking)
Why Vercel?
- Zero-config deployment for React/Vite
- Global CDN for fast asset delivery
- Automatic HTTPS
- Preview deployments for PRs
- Environment variable management
Build Settings:
Framework: Vite
Build Command: npm run build
Output Directory: dist
Why Render over Heroku?
- Free tier without cold starts (paid)
- Native Docker support
- Automatic deploys from GitHub
- Built-in environment variables
- Health checks and auto-restart
Configuration:
Build Command: npm install
Start Command: npm start
Health Check Path: /api/health- Free 512MB cluster
- Automatic backups
- Global regions for low latency
- Built-in monitoring
- IP whitelisting for security
| MongoDB Atlas | Cloud database | | Git & GitHub | Version control |
graph TB
subgraph "Client Layer"
A[React App] --> B[React Router]
A --> C[Framer Motion]
A --> D[Tailwind CSS]
end
subgraph "State Management"
E[Context API] --> F[Auth Context]
E --> G[Theme Context]
end
subgraph "API Layer"
H[Axios Client] --> I[REST API]
I --> J[Auth Middleware]
I --> K[Problem Routes]
I --> L[Analytics Routes]
I --> M[Company Routes]
I --> N[LeetCode Scraper]
end
subgraph "Database Layer"
O[(MongoDB Atlas)] --> P[Users Collection]
O --> Q[Problems Collection]
O --> R[Companies Collection]
O --> S[Patterns Collection]
end
A --> H
I --> O
N --> T[LeetCode API]
style A fill:#61DAFB,stroke:#333,stroke-width:2px
style I fill:#68A063,stroke:#333,stroke-width:2px
style O fill:#47A248,stroke:#333,stroke-width:2px
- Authentication: JWT-based auth with httpOnly cookies
- Problem Management: CRUD operations with auto-save
- Spaced Repetition: Server-side calculation of next reminder dates
- Analytics: MongoDB aggregation pipelines for statistics
- Pattern Recognition: Keyword matching algorithm for auto-tagging
FAANG-Forge/
├── client/ # Frontend React application
│ ├── public/
│ │ └── system-design-data/ # LLD markdown files
│ │ └── lld/
│ │ ├── 01-intro.md
│ │ ├── 02-solid-srp.md
│ │ ├── 13-case-parking-lot.md
│ │ └── ...
│ ├── src/
│ │ ├── components/ # Reusable components
│ │ │ ├── CustomSelect.jsx
│ │ │ ├── Navbar.jsx
│ │ │ └── PageLayout.jsx
│ │ ├── context/ # React Context providers
│ │ │ └── AuthContext.jsx
│ │ ├── pages/ # Route components
│ │ │ ├── DashboardPage.jsx
│ │ │ ├── ProblemsPage.jsx
│ │ │ ├── ProblemDetail.jsx
│ │ │ ├── AnalyticsPage.jsx
│ │ │ ├── SystemDesignPage.jsx
│ │ │ ├── CompaniesPage.jsx
│ │ │ └── LoginPage.jsx
│ │ ├── services/ # API integration
│ │ │ ├── api.js
│ │ │ ├── leetcodeApi.js
│ │ │ └── companyProblemsApi.js
│ │ ├── utils/ # Helper functions
│ │ │ └── constants.js
│ │ ├── styles/
│ │ │ └── theme.js
│ │ ├── App.jsx
│ │ ├── index.css
│ │ └── main.jsx
│ ├── package.json
│ └── vite.config.js
│
├── server/ # Backend Node.js application
│ ├── src/
│ │ ├── controllers/ # Request handlers
│ │ │ ├── authController.js
│ │ │ ├── problemsController.js
│ │ │ ├── analyticsController.js
│ │ │ ├── companyProblemsController.js
│ │ │ └── leetcodeController.js
│ │ ├── models/ # Mongoose schemas
│ │ │ ├── User.js
│ │ │ ├── Problem.js
│ │ │ └── CompanyProblem.js
│ │ ├── routes/ # API routes
│ │ │ ├── auth.routes.js
│ │ │ ├── problems.routes.js
│ │ │ ├── analytics.routes.js
│ │ │ └── companyProblems.routes.js
│ │ ├── middleware/ # Express middleware
│ │ │ └── auth.js
│ │ ├── config/
│ │ │ └── db.js
│ │ ├── data/ # Seed data
│ │ │ └── companies/
│ │ │ └── [company]-problems.csv
│ │ └── server.js
│ ├── package.json
│ └── .env
│
├── .gitignore
├── README.md
└── LICENSE
- Node.js 16+ and npm/yarn
- MongoDB instance (local or Atlas)
- Git
-
Clone the repository
git clone https://github.com/iam-sarthakdev/AlgoFlow.git cd AlgoFlow -
Install dependencies
# Install server dependencies cd server npm install # Install client dependencies cd ../client npm install
-
Configure environment variables
Create
.envin theserverdirectory:PORT=5000 MONGODB_URI=your_mongodb_connection_string JWT_SECRET=your_super_secret_jwt_key NODE_ENV=development
Create
.envin theclientdirectory:VITE_API_URL=http://localhost:5000
-
Seed the database (Optional)
cd server node src/scripts/seedCompanyProblemsLocal.js -
Run the application
# Terminal 1 - Start backend cd server npm run dev # Terminal 2 - Start frontend cd client npm run dev
-
Access the app
Live Production Build:
- Frontend: https://algo-flow-khaki.vercel.app/
Local Environment:
- Frontend:
http://localhost:5173 - Backend:
http://localhost:5000
- Production:
https://faang-forge-api.onrender.com - Development:
http://localhost:5000
// All protected routes require this header
{
"Authorization": "Bearer <JWT_TOKEN>",
"Content-Type": "application/json"
}Create a new user account.
Request Body:
{
"name": "Sarthak Dev",
"email": "user@example.com",
"password": "securePassword123"
}Response (201):
{
"success": true,
"message": "User registered successfully",
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
"user": {
"_id": "507f1f77bcf86cd799439011",
"name": "Sarthak Dev",
"email": "user@example.com"
}
}Login with email and password.
Request Body:
{
"email": "user@example.com",
"password": "securePassword123"
}Response (200):
{
"success": true,
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
"user": {
"_id": "507f1f77bcf86cd799439011",
"name": "Sarthak Dev",
"email": "user@example.com"
}
}Get all user problems with optional filters.
Query Parameters:
| Parameter | Type | Description |
|---|---|---|
topic |
string | Filter by topic (Arrays, Trees, etc.) |
difficulty |
string | Filter by Easy/Medium/Hard |
pattern |
string | Filter by DSA pattern |
search |
string | Search in title/topic |
sort |
string | Sort field (createdAt, difficulty) |
order |
string | asc or desc |
page |
number | Page number (default: 1) |
limit |
number | Items per page (default: 200) |
Response (200):
{
"problems": [
{
"_id": "507f1f77bcf86cd799439011",
"title": "Two Sum",
"topic": "Arrays",
"difficulty": "Easy",
"url": "https://leetcode.com/problems/two-sum",
"patterns": ["Hash Map", "Two Pointers"],
"revision_count": 3,
"next_reminder_date": "2026-01-25T00:00:00.000Z"
}
],
"total": 150,
"page": 1,
"pages": 1
}Create a new problem.
Request Body:
{
"title": "Two Sum",
"url": "https://leetcode.com/problems/two-sum",
"topic": "Arrays",
"difficulty": "Easy",
"notes": "Use hash map for O(n) solution",
"patterns": ["Hash Map"],
"next_reminder_date": "2026-01-25"
}Mark a problem as revised (updates spaced repetition schedule).
Spaced Repetition Algorithm:
// Revision intervals (Ebbinghaus curve)
const intervals = [1, 3, 7, 14, 30, 60, 90]; // days
// Next reminder calculation
const revisionCount = problem.revision_count;
const intervalIndex = Math.min(revisionCount, intervals.length - 1);
const nextDate = new Date();
nextDate.setDate(nextDate.getDate() + intervals[intervalIndex]);Get all problem lists (curated sheets).
Response (200):
{
"success": true,
"lists": [
{
"_id": "507f1f77bcf86cd799439011",
"name": "NeetCode 150",
"description": "The famous Blind 75 + essential patterns",
"isOfficial": true,
"sections": [
{
"title": "Arrays & Hashing",
"problems": [
{
"title": "Contains Duplicate",
"url": "https://leetcode.com/problems/contains-duplicate",
"difficulty": "Easy"
}
]
}
]
}
]
}Seed the database with famous DSA sheets.
Protected Route: Requires admin email (sarthak1712005@gmail.com)
Response (200):
{
"success": true,
"message": "Successfully seeded 4 famous lists",
"lists": ["NeetCode 150", "Striver's A2Z", "NeetCode All", "Love Babbar 450"]
}Get all companies with problem counts.
Response (200):
{
"success": true,
"companies": [
{ "name": "Google", "problemCount": 892, "easy": 150, "medium": 520, "hard": 222 },
{ "name": "Amazon", "problemCount": 756, "easy": 120, "medium": 480, "hard": 156 },
{ "name": "Meta", "problemCount": 623, "easy": 89, "medium": 412, "hard": 122 }
]
}Get problems filtered by company.
Query Parameters:
| Parameter | Type | Description |
|---|---|---|
company |
string | Company name (Google, Amazon, etc.) |
difficulty |
string | Filter by difficulty |
search |
string | Search in problem title |
limit |
number | Max results (default: 200) |
Get user's overall statistics.
Response (200):
{
"totalProblems": 1897,
"solvedProblems": 172,
"totalRevisions": 45,
"currentStreak": 7,
"topicDistribution": {
"Arrays": 45,
"Trees": 32,
"Dynamic Programming": 28,
"Graphs": 21
},
"difficultyBreakdown": {
"Easy": 60,
"Medium": 85,
"Hard": 27
}
}The application uses multiple seeding strategies to populate the database with curated content:
Source: CSV files in server/src/data/companies/
Total Problems: 7,715+ problems from 463+ companies
# Run the seeding script
cd server
node src/scripts/seedCompanyProblemsLocal.jsCSV Format:
title,url,difficulty,topics,companies
"Two Sum","https://leetcode.com/problems/two-sum","Easy","array,hash-table","Google,Amazon,Meta"Process Flow:
CSV Files → Parse → Transform → Upsert to MongoDB (companyproblems collection)
Source: Hardcoded data files in server/src/data/
| File | Sheet | Problems |
|---|---|---|
neetcode150.js |
NeetCode 150 | 150 |
striverA2Z.js |
Striver's A2Z | 455+ |
neetcodeAll.js |
NeetCode All | 250 |
babbar450.js |
Love Babbar 450 | 370+ |
Data Structure:
// Example: server/src/data/neetcode150.js
export default {
name: "NeetCode 150",
description: "The famous Blind 75 + essential patterns for FAANG",
sections: [
{
title: "Arrays & Hashing",
problems: [
{
title: "Contains Duplicate",
url: "https://leetcode.com/problems/contains-duplicate/",
platform: "LeetCode",
difficulty: "Easy"
}
]
}
]
};Seeding Process:
// Triggered via POST /api/lists/seed-famous
const seedFamousLists = async (req, res) => {
// 1. Check admin authorization
if (req.user.email !== 'sarthak1712005@gmail.com') {
return res.status(403).json({ error: 'Admin access required' });
}
// 2. Upsert each sheet
await ProblemList.findOneAndUpdate(
{ name: "NeetCode 150" },
{ $set: neetcode150Data },
{ upsert: true, new: true }
);
// 3. Repeat for all sheets...
};Source: GitHub repositories (OS, DBMS, Networks, OOPs, SQL)
Storage: Fetched dynamically from GitHub API and cached
Topics Covered:
Fundamentals/
├── Operating Systems (18 chapters)
│ ├── Introduction
│ ├── Process Management
│ ├── CPU Scheduling
│ ├── Deadlocks
│ ├── Memory Management
│ └── ...
├── DBMS (15 chapters)
├── Networks (12 chapters)
├── OOPs (10 chapters)
└── SQL (8 chapters)
Source: Local markdown files in client/public/system-design-data/
Structure:
system-design-data/
├── hld/ # High-Level Design
│ ├── system-design-primer.md
│ └── ...
└── lld/ # Low-Level Design
├── 01-intro.md
├── 02-solid-srp.md
├── 13-case-parking-lot.md
└── ...
┌─────────────────────────────────────────────────────────────────┐
│ CLIENT (React) │
├─────────────────────────────────────────────────────────────────┤
│ ProblemsPage.jsx │ CuratedListPage.jsx │ CompaniesPage.jsx │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ fetchProblems() listService.getLists() fetchCompanies() │
└─────────────────────────────────────────────────────────────────┘
│
▼ HTTP/REST
┌─────────────────────────────────────────────────────────────────┐
│ SERVER (Express) │
├─────────────────────────────────────────────────────────────────┤
│ /api/problems │ /api/lists │ /api/company-problems │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ problemController listController companyProblemsController │
└─────────────────────────────────────────────────────────────────┘
│
▼ Mongoose ODM
┌─────────────────────────────────────────────────────────────────┐
│ MONGODB ATLAS │
├─────────────────────────────────────────────────────────────────┤
│ problems (user-specific) │ problemlists │ companyproblems │
│ 1,897+ per user │ 4 sheets │ 7,715+ shared │
└─────────────────────────────────────────────────────────────────┘
{
_id: ObjectId,
name: String,
email: String (unique),
password: String (hashed),
createdAt: Date,
updatedAt: Date
}{
_id: ObjectId,
userId: ObjectId (ref: User),
title: String,
problem_name: String,
topic: String,
difficulty: Enum ['Easy', 'Medium', 'Hard'],
url: String,
notes: String,
codeSnippet: String,
timeComplexity: String,
spaceComplexity: String,
patterns: [String],
companies: [String],
tags: [String],
hints: [String],
isSolved: Boolean,
revision_count: Number,
last_revised_at: Date,
next_reminder_date: Date,
relatedProblems: [ObjectId],
createdAt: Date,
updatedAt: Date
}{
_id: ObjectId,
title: String,
url: String,
difficulty: String,
topics: [String],
companies: [String],
acceptance: Number,
createdAt: Date
}- Push code to GitHub
- Import repository in Vercel
- Set environment variables:
VITE_API_URL=https://your-backend-url.onrender.com
- Deploy
- Create new Web Service in Render
- Connect GitHub repository
- Add MongoDB Atlas connection string
- Set environment variables
- Deploy
- Create free cluster
- Whitelist IP addresses (0.0.0.0/0 for development)
- Create database user
- Get connection string
- Add to backend
.env
Your automated coding growth engine with stats, streak tracking, and weekly activity
Access famous sheets: Sarthak's List, NeetCode 150, Striver's A2Z, NeetCode All, Love Babbar 450
Browse, filter, and manage your DSA problems with pattern tags and revision tracking
Comprehensive CS fundamentals with structured chapters and progress tracking
Learn system design concepts with interactive diagrams and real-world examples
Master the "Soft Skills" with STAR method and psychology-based interview prep
Practice 7700+ problems from 463 companies including FAANG & top-tier firms
Track your preparation activity, difficulty breakdown, and revision streaks
Contributions are welcome! Please follow these steps:
- Fork the repository
- Create a feature branch (
git checkout -b feature/AmazingFeature) - Commit your changes (
git commit -m 'Add some AmazingFeature') - Push to the branch (
git push origin feature/AmazingFeature) - Open a Pull Request
- Follow existing code style
- Write meaningful commit messages
- Add comments for complex logic
- Test your changes thoroughly
- Update documentation if needed
This project is licensed under the MIT License - see the LICENSE file for details.
Sarthak Dev
- GitHub: @iam-sarthakdev
- Email: sarthak1712005@gmail.com
- LinkedIn: Sarthak Dev
- LeetCode for problem inspiration
- Framer Motion for animation library
- Tailwind CSS for styling
- MongoDB for database
- Open source community for amazing tools
If you found this project helpful, please consider giving it a ⭐!
Made with ❤️ by Sarthak Dev