☁️ CloudVault Sentinel

Secure Cloud File Storage & Collaboration Platform

CloudVault is a production-oriented, open-source cloud file storage and collaboration platform designed to help individuals, teams, and organizations securely store, organize, access, share, version, and manage digital files from a centralized platform.

📌 Project Overview

Modern users and organizations manage digital files across laptops, mobile devices, email attachments, messaging platforms, USB drives, local servers, and multiple cloud services.

This creates several real-world problems:

Scattered files
Difficult file discovery
Unauthorized access
Accidental deletion
Lack of file version control
Difficult collaboration
Uncontrolled file sharing
Limited visibility into file activity
Storage management problems
Slow processing of large files

CloudVault aims to solve these problems by providing a centralized, secure, scalable, and cloud-ready file management platform.

The project is designed not merely as a CRUD application, but as a practical backend and cloud engineering project demonstrating:

Backend development
REST API design
Database architecture
Cloud object storage
Authentication and authorization
Asynchronous processing
Caching
File security
Organization management
DevOps
Containerization
CI/CD
Production deployment
System design

🎯 Problem Statement

Individuals and organizations need a reliable way to securely store, organize, share, and manage digital files.

Traditional approaches often distribute files across:

Laptop
   │
   ├── Documents
   ├── Projects
   └── Photos

Mobile
   │
   ├── Images
   └── PDFs

Email
   │
   └── Attachments

USB Drives
   │
   └── Backup Files

Multiple Cloud Services

This makes it difficult to maintain:

Centralized storage
Access control
File ownership
File history
Collaboration
Security
Auditability
Backup and recovery

CloudVault provides a centralized solution.

💡 Vision

The vision of CloudVault is to build a secure and scalable platform where users can:

STORE
  ↓
ORGANIZE
  ↓
SEARCH
  ↓
SHARE
  ↓
COLLABORATE
  ↓
PROTECT
  ↓
MONITOR
  ↓
RECOVER

👥 Target Users

CloudVault is designed for multiple types of users.

🎓 Students

Students can manage:

Notes
Assignments
Projects
Certificates
Resume
Academic documents

Example:

My Drive/
├── College/
│   ├── Notes/
│   ├── Assignments/
│   └── Marksheets/
│
├── Projects/
│   ├── CloudVault/
│   └── ML Project/
│
├── Certificates/
└── Resume/

👨‍💻 Professionals

Professionals can manage:

Resumes
Certificates
Work documents
Reports
Contracts
Project files

👥 Teams

Teams can collaborate through:

Shared folders
Shared files
Team permissions
Organization workspaces
File versioning

🏢 Organizations

Organizations can create:

ABC Technologies
│
├── Engineering
├── HR
├── Finance
├── Sales
└── Management

Each department can have controlled access.

✨ Core Features

🔐 Authentication & Account Management

User registration
Login/logout
JWT authentication
Access and refresh tokens
Password hashing
Password reset
Email verification
Change password
Account management
Active session management
Login history
Optional OAuth authentication
Optional two-factor authentication

👤 User Management

Users can:

Create profiles
Update profiles
Upload avatars
Manage account settings
View storage usage
Manage active sessions
Configure security preferences

📁 File Management

CloudVault provides complete file lifecycle management.

Upload

Single file upload
Multiple file upload
Large file support
File validation
MIME type validation
File size validation
Duplicate detection

File Operations

Upload
Download
Preview
Rename
Move
Copy
Delete
Restore
Favorite
Metadata management

📂 Folder Management

Users can:

Create folders
Rename folders
Delete folders
Move folders
Create nested folders
Share folders
Manage folder permissions

Example:

My Drive/
│
├── Projects/
│   ├── CloudVault/
│   │   ├── Backend/
│   │   ├── Frontend/
│   │   ├── Documentation/
│   │   └── Deployment/
│   │
│   └── ML Project/
│
├── Certificates/
├── Resume/
└── Personal/

☁️ Cloud Storage

CloudVault uses object storage for actual file storage.

The recommended architecture is:

PostgreSQL
    │
    └── File Metadata

AWS S3
    │
    └── Actual File Objects

The database stores information such as:

File ID
File Name
File Size
Owner
MIME Type
Checksum
Storage Key
Created At
Updated At

AWS S3 stores the actual file.

This avoids storing large binary files directly inside PostgreSQL.

🔗 Secure File Sharing

CloudVault supports controlled file sharing.

Users can share files with:

Individual users
Teams
Organizations
Public links

Share links can support:

View-only permission
Download permission
Edit permission
Password protection
Expiration date
Download limits
Revocation

Example:

Share File
    │
    ├── User
    ├── Team
    └── Public Link
            │
            ├── Password
            ├── Expiration
            └── Download Limit

🛡️ Role-Based Access Control

CloudVault uses RBAC to control access.

Example roles:

Organization Owner
        │
        ├── Administrator
        ├── Manager
        ├── Editor
        └── Viewer

Possible permissions:

view
download
upload
edit
rename
move
delete
share
manage_members
manage_organization

Example:

Role	View	Upload	Edit	Delete	Share	Admin
Owner	✅	✅	✅	✅	✅	✅
Admin	✅	✅	✅	✅	✅	✅
Manager	✅	✅	✅	Limited	✅	❌
Editor	✅	✅	✅	Limited	Limited	❌
Viewer	✅	❌	❌	❌	❌	❌

🏢 Organizations & Teams

CloudVault supports multi-user organizations.

An organization can contain:

Organization
│
├── Members
├── Teams
├── Departments
├── Shared Drives
├── Storage Quota
├── Roles
├── Permissions
└── Audit Logs

Example:

ABC Technologies
│
├── Engineering
│   ├── Backend Team
│   └── Frontend Team
│
├── HR
│
├── Finance
│
└── Management

This allows CloudVault to support both personal and business use cases.

🕐 File Versioning

CloudVault can maintain multiple versions of a file.

Example:

Project_Report.pdf

Version 1
Version 2
Version 3
Version 4 ← Current

Users can:

View versions
Download versions
Restore versions
Delete old versions

If a user accidentally uploads an incorrect version, an older version can be restored.

🗑️ Trash & Recovery

Deleted files are moved to Trash instead of being immediately destroyed.

Delete File
     ↓
   Trash
     ↓
Retention Period
     ↓
Restore / Permanent Delete

Features:

Restore files
Permanently delete files
Empty trash
Automatic cleanup

🔎 Search & Filtering

CloudVault provides file discovery through:

Filename search
File type
Folder
Owner
Size
Date
Tags
Metadata

Future versions can support semantic search.

Example:

"Find my AWS deployment documents"

📊 Storage Analytics

Users can monitor:

Storage Used
Storage Available
Total Files
Total Folders
Uploads
Downloads
Shared Files

Example:

Storage

████████████████░░░░

Used: 78 GB
Available: 22 GB

Organization administrators can also monitor storage consumption.

📜 Audit Logging

CloudVault records important security and file activities.

Example actions:

LOGIN
LOGOUT
UPLOAD
DOWNLOAD
VIEW
SHARE
RENAME
MOVE
DELETE
RESTORE
PASSWORD_CHANGE
PERMISSION_CHANGE

Example audit record:

User: Raj
Action: DOWNLOAD
File: project.pdf
Time: 10:42 AM
IP: ********
Device: Chrome / Windows

Audit logs help organizations understand:

Who performed which action, on which resource, and when?

🔔 Notifications

CloudVault can provide:

In-app notifications
Email notifications

Examples:

A user shared a file with you.

You have been invited to an organization.

Your password was changed.

Your shared link is about to expire.

Suspicious activity was detected.

⚙️ Background Processing

CloudVault uses asynchronous processing for tasks that should not block normal HTTP requests.

Examples:

Thumbnail generation
Metadata extraction
Email notifications
File scanning
Cleanup jobs
Report generation
Large file processing

Architecture:

Django
   │
   ▼
Redis
   │
   ▼
Celery Worker
   │
   ├── Thumbnail
   ├── Email
   ├── File Scan
   ├── Metadata
   └── Cleanup

🚀 Redis

Redis is used for high-speed temporary data and background processing infrastructure.

Possible uses:

Celery broker
Caching
Rate limiting
Session storage
Temporary tokens
Frequently accessed metadata

🔄 Celery

Celery is responsible for background task execution.

Example:

generate_thumbnail.delay(file_id)

The task is placed into a queue.

Django
   │
   ▼
Redis
   │
   ▼
Celery Worker
   │
   ▼
Generate Thumbnail

This prevents slow operations from blocking user requests.

⏰ Celery Beat

Celery Beat can schedule recurring jobs.

Example:

Every day at 02:00 AM
        ↓
Celery Beat
        ↓
Delete expired files
        ↓
Redis
        ↓
Celery Worker

Possible scheduled jobs:

Delete expired trash
Remove expired share links
Generate daily reports
Clean temporary files
Recalculate storage statistics

🔐 Security

Security is a core part of CloudVault.

Security mechanisms include:

Secure password hashing
JWT authentication
Role-based access control
Object-level permissions
File validation
MIME type validation
File size restrictions
Rate limiting
Secure signed URLs
HTTPS
CSRF protection
CORS configuration
Security headers
Audit logging
Secure environment variables
Malware scanning
Storage access control

🏗️ System Architecture

High-level architecture:

                         INTERNET
                            │
                            ▼
                        Load Balancer
                            │
                            ▼
                          Nginx
                            │
                            ▼
                       Gunicorn
                            │
                            ▼
                         Django
                            │
          ┌─────────────────┼─────────────────┐
          │                 │                 │
          ▼                 ▼                 ▼
     PostgreSQL           Redis              S3
          │                 │                 │
          │                 ▼                 │
          │          Celery Workers            │
          │                 │                 │
          │        ┌────────┼────────┐        │
          │        ▼        ▼        ▼        │
          │      Email   Thumbnail  Scan      │
          │                                   │
          └───────────────────────────────────┘

📤 File Upload Workflow

The main CloudVault workflow is:

User
 │
 ▼
Select File
 │
 ▼
Django API
 │
 ▼
Authentication
 │
 ▼
Permission Check
 │
 ▼
File Validation
 │
 ▼
Upload to S3
 │
 ▼
Save Metadata in PostgreSQL
 │
 ▼
Create Audit Log
 │
 ▼
Queue Background Tasks
 │
 ▼
Redis
 │
 ▼
Celery Worker
 │
 ├── Generate Thumbnail
 ├── Extract Metadata
 ├── Scan File
 └── Process Preview
 │
 ▼
Update Database
 │
 ▼
Notify User

📥 File Download Workflow

User
 │
 ▼
Request Download
 │
 ▼
Django API
 │
 ▼
Authentication
 │
 ▼
Permission Check
 │
 ▼
Generate Secure/Signed URL
 │
 ▼
AWS S3
 │
 ▼
File Download
 │
 ▼
Audit Log

🔗 File Sharing Workflow

Owner
 │
 ▼
Select File
 │
 ▼
Share
 │
 ▼
Set Permission
 │
 ├── View
 ├── Download
 └── Edit
 │
 ▼
Optional Security
 │
 ├── Password
 ├── Expiration
 └── Download Limit
 │
 ▼
Generate Share Link
 │
 ▼
Recipient

🧩 Technology Stack

Backend

Python
Django
Django REST Framework

Database

PostgreSQL
SQLite for local development/testing when appropriate

Storage

AWS S3

Caching & Queue

Redis
Celery
Celery Beat

Web Server

Nginx
Gunicorn

Frontend

The frontend can be implemented using:

React
TypeScript
Vite
Tailwind CSS

DevOps

Docker
Docker Compose
GitHub Actions
AWS

Documentation

OpenAPI
Swagger
Markdown

📁 Project Structure

cloudvault/
│
├── backend/
│   │
│   ├── config/
│   │   ├── settings/
│   │   │   ├── base.py
│   │   │   ├── development.py
│   │   │   └── production.py
│   │   │
│   │   ├── urls.py
│   │   ├── asgi.py
│   │   ├── wsgi.py
│   │   └── celery.py
│   │
│   ├── apps/
│   │   ├── accounts/
│   │   ├── organizations/
│   │   ├── teams/
│   │   ├── files/
│   │   ├── folders/
│   │   ├── sharing/
│   │   ├── permissions/
│   │   ├── versions/
│   │   ├── trash/
│   │   ├── notifications/
│   │   ├── activities/
│   │   ├── search/
│   │   └── analytics/
│   │
│   ├── common/
│   │   ├── permissions/
│   │   ├── exceptions/
│   │   ├── pagination/
│   │   ├── storage/
│   │   └── utils/
│   │
│   ├── tests/
│   │
│   ├── manage.py
│   │
│   └── requirements/
│       ├── base.txt
│       ├── development.txt
│       └── production.txt
│
├── frontend/
│
├── infrastructure/
│   ├── docker/
│   ├── nginx/
│   ├── aws/
│   └── scripts/
│
├── docs/
│   ├── architecture/
│   ├── api/
│   ├── database/
│   ├── security/
│   └── deployment/
│
├── .github/
│   └── workflows/
│       ├── ci.yml
│       └── cd.yml
│
├── docker-compose.yml
├── Dockerfile
├── .env.example
├── .gitignore
├── LICENSE
├── CONTRIBUTING.md
├── SECURITY.md
├── CODE_OF_CONDUCT.md
├── CHANGELOG.md
└── README.md

🗄️ Database Design

The main entities include:

User
 │
 ├── Organization Membership
 ├── Files
 ├── Folders
 ├── Shares
 ├── Notifications
 └── Activity Logs

Organization
 │
 ├── Members
 ├── Teams
 ├── Roles
 ├── Permissions
 └── Shared Files

File
 │
 ├── Versions
 ├── Shares
 ├── Metadata
 ├── Activity Logs
 └── Storage Object

Conceptual relationship:

User
 │
 ├───────────────┐
 │               │
 ▼               ▼
Organization    File
 │               │
 ▼               ├── Version
Team             ├── Share
 │               ├── Metadata
 ▼               └── Activity
Membership

🌐 API Design

CloudVault follows RESTful API principles.

Example endpoints:

Authentication

POST   /api/v1/auth/register/
POST   /api/v1/auth/login/
POST   /api/v1/auth/refresh/
POST   /api/v1/auth/logout/
POST   /api/v1/auth/password/reset/

Files

GET    /api/v1/files/
POST   /api/v1/files/
GET    /api/v1/files/{id}/
PATCH  /api/v1/files/{id}/
DELETE /api/v1/files/{id}/
GET    /api/v1/files/{id}/download/

Folders

GET    /api/v1/folders/
POST   /api/v1/folders/
GET    /api/v1/folders/{id}/
PATCH  /api/v1/folders/{id}/
DELETE /api/v1/folders/{id}/

Sharing

POST   /api/v1/shares/
GET    /api/v1/shares/
DELETE /api/v1/shares/{id}/

Organizations

GET    /api/v1/organizations/
POST   /api/v1/organizations/
GET    /api/v1/organizations/{id}/
PATCH  /api/v1/organizations/{id}/
DELETE /api/v1/organizations/{id}/

API documentation will be provided using OpenAPI/Swagger.

🐳 Docker Architecture

CloudVault can run locally through Docker Compose.

Example services:

cloudvault-web
cloudvault-db
cloudvault-redis
cloudvault-worker
cloudvault-beat
cloudvault-nginx

Architecture:

                    Docker Compose
                          │
       ┌──────────┬───────┼────────┬───────────┐
       ▼          ▼       ▼        ▼           ▼
     Django   PostgreSQL Redis   Celery     Nginx
                                Worker
                                  │
                               Celery Beat

⚙️ Local Development

1. Clone the repository

git clone https://github.com/<your-username>/cloudvault.git
cd cloudvault

2. Create virtual environment

Windows

python -m venv .venv
.venv\Scripts\activate

Linux/macOS

python3 -m venv .venv
source .venv/bin/activate

3. Install dependencies

pip install -r backend/requirements/development.txt

4. Configure environment

Copy:

.env.example

to:

.env

Configure:

SECRET_KEY=
DEBUG=
DATABASE_URL=
REDIS_URL=
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_STORAGE_BUCKET_NAME=
AWS_REGION=

5. Run migrations

python backend/manage.py migrate

6. Create superuser

python backend/manage.py createsuperuser

7. Start Django

python backend/manage.py runserver

🐳 Docker Development

Build containers:

docker compose build

Start services:

docker compose up

Run in background:

docker compose up -d

Run migrations:

docker compose exec web python manage.py migrate

Create superuser:

docker compose exec web python manage.py createsuperuser

Stop:

docker compose down

🧪 Testing

CloudVault should maintain automated tests for:

Authentication
Authorization
File uploads
File downloads
File permissions
Folder operations
Sharing
Versioning
Trash
Organizations
API endpoints
Celery tasks
Storage operations

Run tests:

pytest

or:

python manage.py test

🔄 CI/CD

GitHub Actions can automatically run:

Push
 │
 ▼
GitHub Actions
 │
 ├── Lint
 ├── Unit Tests
 ├── Integration Tests
 ├── Security Checks
 ├── Docker Build
 └── Deployment

Production workflow:

Developer
    │
    ▼
Feature Branch
    │
    ▼
Pull Request
    │
    ▼
Code Review
    │
    ▼
Merge
    │
    ▼
CI
    │
    ▼
Build Docker Image
    │
    ▼
Deploy

🌍 Production Deployment

A production deployment can use:

                    AWS
                     │
          ┌──────────┼──────────┐
          ▼          ▼          ▼
        EC2         S3       PostgreSQL
          │
        Nginx
          │
      Gunicorn
          │
        Django
          │
        Redis
          │
       Celery

Production infrastructure can later evolve to:

Route 53
   ↓
CloudFront
   ↓
Load Balancer
   ↓
EC2 / ECS
   ↓
Django

📈 Scalability Strategy

CloudVault should be designed so application components can scale independently.

Example:

                  Load Balancer
                       │
          ┌────────────┼────────────┐
          ▼            ▼            ▼
       Django 1     Django 2     Django 3
          │            │            │
          └────────────┼────────────┘
                       ▼
                     Redis
                       │
          ┌────────────┼────────────┐
          ▼            ▼            ▼
      Worker 1      Worker 2      Worker 3

AWS S3 provides scalable object storage while application servers remain responsible primarily for metadata and API operations.

🔐 Environment Variables

Never commit secrets to Git.

Use:

.env

Example:

SECRET_KEY=your-secret-key
DEBUG=False

DATABASE_URL=postgresql://user:password@db:5432/cloudvault

REDIS_URL=redis://redis:6379/0

AWS_ACCESS_KEY_ID=your-access-key
AWS_SECRET_ACCESS_KEY=your-secret-key
AWS_STORAGE_BUCKET_NAME=cloudvault
AWS_REGION=ap-south-1

Only commit:

.env.example

📋 Git Workflow

Recommended branch structure:

main
 │
 └── develop
       │
       ├── feature/authentication
       ├── feature/file-upload
       ├── feature/file-sharing
       ├── feature/versioning
       ├── feature/organizations
       └── feature/analytics

Development process:

Issue
 ↓
Feature Branch
 ↓
Implementation
 ↓
Testing
 ↓
Pull Request
 ↓
Code Review
 ↓
Merge
 ↓
CI/CD
 ↓
Release

📝 Commit Convention

CloudVault follows conventional commit-style messages.

Examples:

feat: add JWT authentication

feat: implement file upload API

feat: integrate AWS S3 storage

feat: add organization management

feat: implement secure file sharing

feat: add file versioning

fix: validate uploaded file MIME type

fix: resolve storage quota calculation

test: add file upload API tests

docs: add deployment documentation

chore: configure Docker environment

Avoid commits such as:

update
changes
final
done

📦 Release & Versioning

CloudVault follows Semantic Versioning:

MAJOR.MINOR.PATCH

Examples:

v0.1.0
v0.2.0
v0.5.0
v1.0.0
v1.1.0
v2.0.0

Version meaning

MAJOR

Breaking changes.

v1.x.x → v2.x.x

MINOR

New backward-compatible features.

v1.1.0 → v1.2.0

PATCH

Bug fixes.

v1.2.0 → v1.2.1

🗺️ Roadmap

Phase 1 — Foundation

Phase 2 — File Management

Phase 3 — Cloud Storage

Phase 4 — Sharing

Phase 5 — Background Processing

Phase 6 — Organizations

Phase 7 — Advanced Features

Phase 8 — DevOps

Phase 9 — Intelligent Features

🧠 Future AI Features

Future versions may include:

Semantic Search

Instead of only searching filenames:

"Find my AWS deployment documents"

CloudVault can search document content and metadata.

Document Classification

Automatically categorize:

Resume
Invoice
Certificate
Contract
Report
Assignment

OCR

Extract text from scanned documents.

AI Document Assistant

Users could ask:

"Summarize this document."

"Find the payment deadline."

"What are the important points?"

These features are planned for future versions and are not required for the initial MVP.

🌟 What Makes CloudVault Different?

CloudVault is not intended to be just:

Login
Upload
Download
Delete

Instead, the platform combines:

Cloud Storage
      +
Secure Sharing
      +
RBAC
      +
Organizations
      +
Teams
      +
Version Control
      +
Audit Logging
      +
Background Processing
      +
Analytics
      +
Developer API
      +
DevOps

This makes CloudVault a practical project for learning production-oriented backend and cloud engineering.

🎯 Real-World Use Cases

Students

Store:

Notes
Projects
Certificates
Academic documents

Professionals

Store:

Resumes
Contracts
Reports
Work documents

Teams

Manage:

Project files
Documentation
Shared resources

Small Businesses

Manage:

HR documents
Finance documents
Business reports
Contracts

Organizations

Manage:

Departments
Users
Permissions
Shared drives
Audit logs

🏆 Learning Objectives

Building CloudVault provides practical experience with:

Python

OOP
Modules
Exception handling
Async/background processing concepts

Django

Models
Views
URLs
Middleware
Authentication
Permissions
Django ORM
REST APIs

Databases

PostgreSQL
Relationships
Indexing
Transactions
Query optimization

Cloud

AWS S3
EC2
IAM
Networking concepts
Cloud architecture

Backend Engineering

REST API
Authentication
Authorization
Caching
File processing
Distributed task processing

DevOps

Docker
Nginx
Gunicorn
CI/CD
Linux
Deployment

System Design

Scalability
Reliability
Security
Fault tolerance
Background processing

🤝 Contributing

CloudVault is intended to be open source and welcomes contributions.

Contribution workflow

Fork
 ↓
Clone
 ↓
Create Branch
 ↓
Implement Feature
 ↓
Write Tests
 ↓
Commit
 ↓
Push
 ↓
Pull Request
 ↓
Code Review

Example:

git clone https://github.com/<your-username>/cloudvault.git

cd cloudvault

git checkout -b feature/file-sharing

After development:

git add .
git commit -m "feat: implement secure file sharing"
git push origin feature/file-sharing

Then open a Pull Request.

📜 Open Source

CloudVault is built using widely adopted open-source technologies.

Core technologies include:

Python
Django
Django REST Framework
PostgreSQL
Redis
Celery
React
Docker
Nginx
Gunicorn

Third-party dependencies should be used according to their respective licenses.

📄 License

This project is licensed under the MIT License.

See:

LICENSE

for more information.

🔒 Security Policy

If you discover a security vulnerability, please do not publicly disclose it through a GitHub issue.

Instead, follow the instructions in:

SECURITY.md

Security-related contributions are highly appreciated.

📚 Documentation

Detailed documentation will be maintained under:

docs/
├── architecture/
├── api/
├── database/
├── security/
└── deployment/

Planned documentation:

System Architecture
Database Design
API Documentation
Authentication Flow
Authorization Model
File Upload Flow
AWS S3 Architecture
Redis Architecture
Celery Architecture
Docker Setup
Production Deployment
Security Guide
Contribution Guide

📊 Project Status

Status: 🚧 Active Development
Version: 0.1.0

CloudVault is being developed incrementally, starting with the core file-management system and gradually expanding toward a production-oriented cloud platform.

📌 Development Philosophy

CloudVault follows these principles:

Security First
    ↓
Clean Architecture
    ↓
Testable Code
    ↓
API-First Design
    ↓
Scalable Infrastructure
    ↓
Automation
    ↓
Documentation

The goal is not simply to build more features, but to understand why each component exists and how the complete system works together.

🚀 Long-Term Vision

The long-term goal is to evolve CloudVault into a complete cloud document and collaboration platform.

                         CLOUDVAULT
                             │
        ┌────────────────────┼────────────────────┐
        ▼                    ▼                    ▼
   Personal Storage      Team Storage       Organization
        │                    │                    │
        ▼                    ▼                    ▼
      Files              Collaboration          RBAC
        │                    │                    │
        └────────────────────┼────────────────────┘
                             ▼
                        Secure Sharing
                             │
                             ▼
                         Versioning
                             │
                             ▼
                        Audit Logging
                             │
                             ▼
                    Background Processing
                             │
                             ▼
                       Cloud Storage
                             │
                             ▼
                      Scalable Backend
                             │
                             ▼
                       Intelligent Search

⭐ Why CloudVault?

CloudVault is designed as more than a traditional Django CRUD project.

It demonstrates how a modern application can combine:

Python + Django + REST APIs + PostgreSQL + Redis + Celery + AWS S3 + Docker + Nginx + Gunicorn + CI/CD + Security + System Design

into one cohesive production-oriented platform.

👨‍💻 Project Author

Raj Shekhar

Computer Science Engineering Student Backend & Cloud Engineering Enthusiast

Interested in:

Python
Django
Backend Engineering
Cloud Computing
DevOps
System Design
Distributed Systems

⭐ Support the Project

If you find CloudVault useful:

⭐ Star the repository
🍴 Fork the project
🐛 Report issues
💡 Suggest features
🔧 Submit pull requests
📖 Improve documentation

☁️ CloudVault

Store securely. Share confidently. Collaborate efficiently.

Built with Python, Django, PostgreSQL, Redis, Celery, Docker, and AWS.

Quick start (local)

Create and activate a virtualenv:

python -m venv .venv
.\.venv\Scripts\Activate.ps1

Install dependencies:

python -m pip install -r requirements.txt

Run migrations:

python manage.py makemigrations
python manage.py migrate

Start ASGI server (recommended) to enable WebSockets:

.\run_asgi.ps1    # uses daphne by default
# or: .\run_asgi.ps1 -Server uvicorn

Open http://127.0.0.1:8000/ and log in.

Pushing to GitHub (recommended automated commits)

Use the provided script to create up to 100 professional commits and push them.

# Dry run (preview planned commits)
.\scripts\create_commits.ps1 -RemoteUrl "git@github.com:USERNAME/REPO_NAME.git" -MaxCommits 100 -DryRun

# Execute and push
.\scripts\create_commits.ps1 -RemoteUrl "git@github.com:USERNAME/REPO_NAME.git" -MaxCommits 100 -PushAfterCommit

CI

A basic GitHub Actions workflow is included in .github/workflows/ci.yml that installs requirements, runs migrations and runs tests.

Notes

Ensure .env or other secret files are never committed. .gitignore includes .env.
For production, configure SECRET_KEY, DEBUG=False, ALLOWED_HOSTS, and a production-ready DATABASES (Postgres) and REDIS_URL for Channels.

License

Internal/Proprietary (change as needed)

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
accounts		accounts
analytics		analytics
cloudvault		cloudvault
scripts		scripts
sharing		sharing
static		static
storage		storage
templates		templates
.gitignore		.gitignore
ASGI_RUN.md		ASGI_RUN.md
Dockerfile		Dockerfile
README.md		README.md
create_demo_data.py		create_demo_data.py
docker-compose.prod.yml		docker-compose.prod.yml
docker-compose.yml		docker-compose.yml
docker-entrypoint.sh		docker-entrypoint.sh
manage.py		manage.py
nginx.conf		nginx.conf
render.yaml		render.yaml
requirements.txt		requirements.txt
run_asgi.ps1		run_asgi.ps1
run_full_verification.py		run_full_verification.py
start.sh		start.sh

Latest commit

History

Folders and files

Repository files navigation

☁️ CloudVault Sentinel

Secure Cloud File Storage & Collaboration Platform

📌 Project Overview

🎯 Problem Statement

💡 Vision

👥 Target Users

🎓 Students

👨‍💻 Professionals

👥 Teams

🏢 Organizations

✨ Core Features

🔐 Authentication & Account Management

👤 User Management

📁 File Management

Upload

File Operations

📂 Folder Management

☁️ Cloud Storage

🔗 Secure File Sharing

🛡️ Role-Based Access Control

🏢 Organizations & Teams

🕐 File Versioning

🗑️ Trash & Recovery

🔎 Search & Filtering

📊 Storage Analytics

📜 Audit Logging

🔔 Notifications

⚙️ Background Processing

🚀 Redis

🔄 Celery

⏰ Celery Beat

🔐 Security

🏗️ System Architecture

📤 File Upload Workflow

📥 File Download Workflow

🔗 File Sharing Workflow

🧩 Technology Stack

Backend

Database

Storage

Caching & Queue

Web Server

Frontend

DevOps

Documentation

📁 Project Structure

🗄️ Database Design

🌐 API Design

Authentication

Files

Folders

Sharing

Organizations

🐳 Docker Architecture

⚙️ Local Development

1. Clone the repository

2. Create virtual environment

Windows

Linux/macOS

3. Install dependencies

4. Configure environment

5. Run migrations

6. Create superuser

7. Start Django

🐳 Docker Development

🧪 Testing

🔄 CI/CD

🌍 Production Deployment

📈 Scalability Strategy

🔐 Environment Variables

📋 Git Workflow

📝 Commit Convention

📦 Release & Versioning

Version meaning

MAJOR

MINOR