StreamCore is a full-stack video sharing platform built to explore and implement modern web application architecture. The project focuses primarily on backend engineering concepts such as authentication, authorization, media handling, API design, database relationships, and scalable application structure, while also providing a complete React-based frontend experience.
The goal of this project was to move beyond tutorial-level CRUD applications and gain hands-on experience building a production-style backend system with real-world patterns and workflows.
StreamCore provides the core functionality expected from a modern video platform:
- User authentication and account management
- Video upload and management
- Channel subscriptions
- Comments and likes
- Playlists
- User activity tracking
- Creator dashboard and analytics
- Media storage and delivery
The application follows a modular architecture with a clear separation of concerns between routes, controllers, middleware, services, and data models.
- User registration and login
- JWT-based authentication
- Access and refresh token flow
- Protected routes
- Secure cookie handling
- Password management
- Current user sessions
- Profile management
- Avatar uploads
- Cover image uploads
- Watch history tracking
- Channel profile pages
- Video publishing
- Thumbnail management
- Video updates and deletion
- Publish/unpublish functionality
- Video browsing and discovery
- Channel-specific content
- Video likes
- Comment likes
- Tweet likes
- Video comments
- Creator subscriptions
- User engagement tracking
- Create playlists
- Update playlists
- Delete playlists
- Add videos to playlists
- Remove videos from playlists
- Channel statistics
- Subscriber counts
- Video analytics
- Creator activity overview
- Cloudinary integration
- Multer-based file uploads
- Image processing workflow
- Video asset management
- Node.js
- Express.js
- MongoDB
- Mongoose
- JSON Web Tokens (JWT)
- Refresh Token Strategy
- Cookie-based Authentication
- Cloudinary
- Multer
- React
- Vite
- React Router
- Axios
- Tailwind CSS
- TanStack Query
- bcrypt
- cookie-parser
- cors
- dotenv
The project follows a layered backend architecture:
Client
│
▼
Routes
│
▼
Middlewares
│
▼
Controllers
│
▼
Models
│
▼
MongoDB
Authentication, file uploads, request validation, error handling, and API responses are implemented using reusable middleware and utility layers.
src/
│
├── controllers/
├── models/
├── routes/
├── middlewares/
├── utils/
├── db/
│
├── app.js
└── index.js
Create a .env file in the root directory:
PORT=
MONGODB_URI=
CORS_ORIGIN=
ACCESS_TOKEN_SECRET=
ACCESS_TOKEN_EXPIRY=
REFRESH_TOKEN_SECRET=
REFRESH_TOKEN_EXPIRY=
CLOUDINARY_CLOUD_NAME=
CLOUDINARY_API_KEY=
CLOUDINARY_API_SECRET=Clone the repository:
git clone https://github.com/subhasankarsahu/Project-Stream-Core.gitMove into the project directory:
cd Project-Stream-CoreInstall dependencies:
npm installConfigure environment variables:
cp .env.example .envStart the development server:
npm run devThe backend is organized into the following modules:
- Users
- Authentication
- Videos
- Comments
- Likes
- Subscriptions
- Playlists
- Tweets
- Dashboard
- Healthcheck
All APIs are versioned under:
/api/v1
The frontend provides a complete user experience built on top of the backend APIs.
Key frontend features include:
- Authentication flows
- Video browsing and viewing
- Creator channels
- Video uploads
- Dashboard analytics
- Playlist management
- Responsive layouts
- Protected routes
- State management and API integration
While the project includes a complete frontend application, the primary focus remains on backend system design, API development, authentication flows, media handling, and database architecture.
This project was developed as a practical learning exercise to gain hands-on experience with modern backend development and full-stack application architecture.
Key areas explored include:
- REST API Design
- Authentication & Authorization
- JWT Access and Refresh Token Flows
- MongoDB Data Modeling
- Mongoose Aggregation Pipelines
- Middleware Architecture
- File Upload Workflows
- Cloudinary Integration
- Error Handling Strategies
- Backend Project Structure
- Scalable Application Design
- Frontend and Backend Integration
The emphasis was placed on understanding how production-oriented backend systems are organized and implemented rather than simply replicating isolated features.
Potential areas for future development include:
- Redis-based caching
- WebSocket support
- Background job processing
- Automated testing
- Docker containerization
- CI/CD pipelines
- API documentation with Swagger/OpenAPI
- PostgreSQL implementation
- Advanced analytics
- Search and recommendation systems
This project was built for educational and portfolio purposes to practice and reinforce full-stack development concepts. It is intended as a learning-focused implementation of production-inspired architecture and patterns rather than a commercial-grade platform.
This project was originally inspired by and developed while following the backend development series by Hitesh Choudhary.
The foundational architecture, concepts, and learning approach were derived from the course material. The project was further extended, completed, and customized as part of a personal learning journey to gain practical experience in backend and full-stack application development.
Special thanks to Hitesh Choudhary for creating accessible and industry-oriented educational content that made this project possible.
This repository is intended for educational and portfolio purposes only.
Please refer to the original course and learning materials by Hitesh Choudhary before reusing any course-specific content. All additional implementations, extensions, and modifications in this repository were created as part of personal learning and practice.