A Synopsis Report

on

READERCLUB

Submitted in partial fulfillment of the requirements

for the award of the degree of

Bachelor of Technology
in
Computer Science & Engineering

SUBMITTED TO: SUBMITTED BY:

Ms Arunima Sengupta Devesh Rana
(2213021145)
Btech CSE (AIML)
2021-25

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

FACULTY OF ENGINEERING AND TECHNOLOGY

SGT UNIVERSITY, GURUGRAM

March, 2025
 Certificate
This is to certify that the synopsis report READERCLUB submitted by Devesh Rana in partial fulfillment

for the award of the Degree of Bachelor of Technology to the SGT University is a record of bonafied

carried out by her under my guidance and supervision during the year 2021-2025. The results embodied

in this project report have not been submitted to any other University or Institute for the award of any Degree.

(Supervisor Signature with Date)

Name of the Supervisor:
Designation:

Program Head

Head of Department,
Computer Science & Engineering,
Faculty of Engineering and Technology
 CANDIDATE'S DECLARATION

I Devesh Rana i hereby declare that I have under taken Semester Training at Cincooni Systems

during a period from 9 December 2024 to 31 March 2025 in partial fulfillment of requirements for

the award of degree of Bachelors of Technology at SGT University, Gurugram. The work which

is being presented in the training report submitted to Department of Computer Science and

Engineering at SGT University, Gurugram an authentic record of training work.

(Student Signature with Date)

Devesh Rana
(221302145)
Semester: 8th
 Abstract
The EdTech Learning is a Django-based web application designed to facilitate seamless online learning and
certification. The platform enables users to register, browse and enroll in courses, take exams, and receive
digital certificates based on their performance. It integrates key components such as user authentication, an
exam portal, certificate management, and job listings to create a comprehensive learning experience.

Frontend Development:

The frontend is built using HTML, CSS and JavaScript to ensure a responsive and user-friendly interface. It
provides:

 User Dashboard – Displays enrolled courses, upcoming exams, and certificates earned.
 Course Listing & Enrollment – Users can browse available courses and register easily.
 Exam Interface – A real-time, interactive quiz system for answering questions with timers and progress
indicators.
 Results & Certificate View – Displays user scores, pass/fail status, and dynamically generates downloadable
certificates.
 Filtering & Sorting Features – Enables job seekers to filter job listings by company, domain, experience, and
salary.

Backend Development:

The backend is powered by Django and Django REST Framework (DRF), ensuring a scalable and secure
API-driven architecture. Key backend functionalities include:

 User Authentication: Implements Django's authentication system with Google OAuth for easy login/signup.
 Course & Exam Management: Enables admins to create and manage courses, exams, and assessments.
 Automated Exam Evaluation: Uses backend logic to compute results instantly and determine certificate
eligibility.
 Certificate Generation & Verification: Generates PDF certificates with unique IDs, stored securely for
verification.
 Job Listing & Filtering API: Allows recruiters to post jobs while users can filter and apply based on various
criteria.
 Database Management: Uses PostgreSQL for structured data storage and retrieval, ensuring optimized
performance.
 REST API: Build a fully functional API using REST framework for the project that can perform CRUD
operations using Postman.
Tools and Technologies Used in the Project
The EdTech Learning & Certification Platform is built using a modern technology
stack to ensure scalability, security, and seamless user experience. The project is
developed using the following tools and technologies:

1. Frontend Technologies:

 HTML5 & CSS3: Used for structuring and styling the web pages.
 JavaScript (ES6+): Implements interactive features and dynamic content.
 Tailwind CSS: Provides a utility-first CSS framework for faster styling.

2. Backend Technologies:

 Django: A Python-based web framework that follows the MVT (Model-View-

Template) architecture.
 Django REST Framework (DRF): Enables the creation of RESTful APIs to handle
client-server communication.
 PostgreSQL: A relational database used for storing user, course, exam, and
certification data securely.
 Redis: Utilized for caching to improve API response time and session management.

3. Authentication & Security:

 Django Authentication System: Manages user login, registration, and authorization.

 Google OAuth 2.0: Provides secure and seamless social authentication.
 JWT (JSON Web Tokens): Used for secure token-based authentication in API
requests.

4. Exam & Certificate Management:

 Python Libraries (ReportLab, PIL): Used for generating digital certificates in

PDF format.
 Celery & Redis: Handles asynchronous tasks, such as sending email notifications
and processing large datasets.

5. Deployment & DevOps:

 Docker: Containerizes the application for a consistent deployment environment.

 NGINX & Gunicorn: Used for deploying the Django application in a production-
ready setup.
 AWS / DigitalOcean: Provides cloud hosting for scalability and reliability.
 Git & GitHub: Version control system used for tracking code changes and
collaboration.

6. API Integration & External Services:

 Job Portal APIs: Allows integration with external job boards for expanding job
listing capabilities.
 RESTful API Development: Ensures the platform can be accessed by mobile apps
and third-party services.
The combination of Django, React, REST APIs, and cloud-based deployment
makes the EdTech Learning & Certification Platform a secure, scalable, and
high-performance system. The use of modern authentication methods, automated
evaluation, and certificate generation ensures a smooth user experience.
Workflow of the Project
Here’s a detailed breakdown of the files and their purposes, along with their internal
workings, for a comprehensive report:

1. manage.py
- Purpose: A command-line utility that allows interaction with the Django project.
- Internal Work:
- Used to run development server: `python manage.py runserver`.
- Handles database migrations: `python manage.py makemigrations` and `python
manage.py migrate`.
- Creates superusers for the admin panel: `python manage.py createsuperuser`.
- Runs tests: `python manage.py test`.

2. models.py
- Purpose: Defines the database schema using Python classes.
- Internal Work:
- Each class represents a database table.
- Fields in the class represent table columns (e.g., `CharField`, `IntegerField`).
- Relationships (e.g., `ForeignKey`, `ManyToManyField`) define how tables are
linked.
- Example:
```python
class UserProfile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
bio = models.TextField()
```

3. views.py
- Purpose: Handles the logic for processing HTTP requests and returning responses.
- Internal Work:
- Functions or classes process user input, interact with models, and render
templates.
- Example:
```python
def home(request):
return render(request, 'home.html')
```

4. admin.py
- Purpose: Configures the Django admin interface for managing database records.
- Internal Work:
- Registers models to make them editable in the admin panel.
- Example:
```python
from django.contrib import admin
from .models import UserProfile
admin.site.register(UserProfile)
```

5. urls.py
- Purpose Maps URLs to views.
- Internal Work:
- Defines URL patterns and associates them with view functions or classes.
- Example:
```python
from django.urls import path
from . import views
urlpatterns = [
path('', views.home, name='home'),
]
```

6. `forms.py`
- Purpose: Handles form creation, validation, and processing.
- Internal Work:
- Defines forms using Django’s `Form` or `ModelForm` classes.
- Example:
```python
from django import forms
from .models import UserProfile
class ProfileForm(forms.ModelForm):
class Meta:
model = UserProfile
fields = ['bio']
```

7. `templates/`
- Purpose: Stores HTML templates for rendering web pages.
- Internal Work:
- Templates use Django’s templating language to dynamically render data.
- Example:
```html
<h1>Welcome, {{ user.username }}!</h1>
```

8. `migrations/`
- Purpose: Tracks changes to the database schema.
- Internal Work:
- Contains migration files generated by Django when models are modified.
- Migrations are applied using `python manage.py migrate`.

9. `tests.py`
- Purpose: Contains test cases to ensure the application works as expected.
- Internal Work:
- Uses Django’s testing framework to write unit and integration tests.
- Example:
```python
 from django.test import TestCase
from .models import UserProfile
class ProfileTestCase(TestCase):
def test_profile_creation(self):
profile = UserProfile.objects.create(bio="Test bio")
self.assertEqual(profile.bio, "Test bio")
```

10. `requirements.txt`
- Purpose: Lists all Python dependencies required for the project.
- Internal Work:
- Used by `pip` to install packages: `pip install -r requirements.txt`.
- Example:
```
Django==4.2
psycopg2-binary==2.9.6
```

11. `Dockerfile`
- Purpose: Defines the Docker container setup for the application.
- Internal Work:
- Specifies the base image, dependencies, and commands to run the app.
- Example:
```dockerfile
FROM python:3.9
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
```

12. `entrypoint.sh`
- Purpose: Script executed when the Docker container starts.
- Internal Work:
- Runs commands to set up and start the application.
- Example:
```bash
#!/bin/bash
python manage.py migrate
python manage.py runserver 0.0.0.0:8000
```

13. `logs/`
-Purpose: Stores application logs for debugging and monitoring.
- Internal Work:
- Contains files with runtime information, errors, and warnings.

14. `media/`
- Purpose: Stores user-uploaded files (e.g., images, documents).
 - Internal Work:
- Files are saved here when users upload content via forms.

15. `policies/`
- Purpose: Stores policy documents (e.g., privacy policy, terms of service).
- Internal Work:
- Contains text or markdown files outlining project policies.

16. `roadmap`
- Purpose: Outlines project milestones and future plans.
- Internal Work:
- Contains a timeline or list of features to be implemented.

17. `credentials/`
- Purpose: Stores sensitive information like API keys or database credentials.
- Internal Work:
- Contains configuration files or environment variables.

18. `api/`
- Purpose: Handles API-related functionality.
- Internal Work:
- Contains views, serializers, and routing for RESTful APIs.

19. `docker-compose.yml`
- Purpose: Defines multi-container Docker applications.
- Internal Work:
- Configures services like the Django app, database, and Redis.

20. `README.md`
- Purpose: Provides an overview of the project.
- Internal Work:
- Contains instructions for setup, usage, and contribution.