1.

1 Introduction
The Online Job Management System is a full-stack web application designed to facilitate
seamless interaction between employers and job seekers. Built using Django, this platform
digitizes the entire recruitment workflow—from job posting to application and hiring. It replaces
traditional hiring methods with a structured, automated solution that’s scalable and user-friendly.

The system comprises user role management (admin, employer, candidate), secure login/signup,
job posting and application modules, and a backend dashboard for system management.

1.2 Objective
• Digitize the recruitment lifecycle to reduce manual effort and error.
• Facilitate a centralized space for job seekers and recruiters.
• Allow employers to post jobs and filter applicants based on resumes.
• Enable job seekers

1.3 Modules (Detailed)

1. Accounts Module

Handles all user authentication and role-based access control.

Features:

• Registration with role selection (Candidate/Employer)

• Login & logout
• Profile management
• Django’s built-in user model extension using AbstractUser

Code Snippet:

# accounts/models.py

from django.contrib.auth.models import AbstractUser

from django.db import models

class CustomUser(AbstractUser):

ROLE_CHOICES = (

('candidate', 'Candidate'),

('employer', 'Employer'),
 )

role = models.CharField(max_length=10, choices=ROLE_CHOICES)

2. JobsApp Module

This is the heart of the system, managing job postings and applications.

Features:

• Employers can create, update, delete jobs

• Candidates can view jobs and apply
• Resume upload and storage
• Application status updates

Code Snippet:

# jobsapp/models.py

class Job(models.Model):

title = models.CharField(max_length=200)

description = models.TextField()

company = models.CharField(max_length=100)

posted_by = models.ForeignKey(CustomUser, on_delete=models.CASCADE)

class Application(models.Model):

job = models.ForeignKey(Job, on_delete=models.CASCADE)

applicant = models.ForeignKey(CustomUser, on_delete=models.CASCADE)

resume = models.FileField(upload_to='resumes/')

status = models.CharField(default='Pending', max_length=20)

3. Admin Module

Admins use Django’s powerful admin interface to monitor and control system behavior.

Features:

• View all users and roles

• Remove spam/invalid jobs
• Reset application status
• Dashboard metrics via Django Admin
2.1 Survey Description
A detailed requirement gathering was done by analyzing:

• Job seekers’ needs for resume uploads, job filtering

• Recruiters’ needs for easy posting and candidate management
• Admins’ need for complete oversight

Observations:

• Users need mobile-friendly, simple UIs.

• Employers prefer quick dashboard-based tools.
• Admins require user logs and moderation tools.

2.2 Languages Used

Frontend:

• HTML5/CSS3: Layout and styling

• Bootstrap: Responsive design
• JavaScript: Dynamic behavior (e.g., job filters)

Backend:

• Python (Django Framework): Main backend logic and ORM

• SQLite: Lightweight DBMS for dev
• Django Templating Engine: Renders views securely

3.1 Requirement Specifications

Functional Requirements:

• Multi-role login system

• Job posting and application
• Resume management
• Application status tracking
• Admin-level moderation

Non-Functional Requirements:

• Security: hashed passwords, file restrictions

• Scalability: DB migrations, app separation
• Performance: ORM optimizations
• Usability: Responsive UI, intuitive forms
3.2 Hardware & Software Requirements
Hardware:

• CPU: Dual-core or better

• RAM: 4GB minimum
• Disk: 1GB for logs/uploads

Software:

• OS: Windows/Linux/macOS
• Python 3.9+
• Django 4.x
• SQLite (or PostgreSQL for production)
• Code Editor (VSCode/PyCharm)

3.4 Normalization
Database is normalized to 3NF:

• 1NF: Each field contains atomic values.

• 2NF: All non-key fields depend fully on the primary key.
• 3NF: No transitive dependency between non-key attributes.

Sample Schema:

• User(user_id, email, password, role)

• Job(job_id, title, description, company, posted_by)
• Application(app_id, job_id, applicant_id, resume, status)

4.1 Code Details and Code Efficiency

Project Structure:
/project

/accounts

/jobsapp

/templates

/static

manage.py
Key Files Overview:

• models.py: DB schema
• views.py: Handles request logic
• urls.py: Routing
• templates/: HTML files with inheritance
• admin.py: Admin panel customizations

Efficient Use of Django ORM

Example: Filtering jobs by company:

# jobsapp/views.py

def job_list(request):

jobs = Job.objects.filter(company__icontains=request.GET.get("company", ""))

return render(request, 'jobsapp/job_list.html', {'jobs': jobs})

• Avoids raw SQL

• Filters done in the DB layer

• Prevents SQL injection

Resume Upload Handling

# forms.py

class ApplicationForm(forms.ModelForm):

class Meta:

model = Application

fields = ['resume']

# views.py

def apply_job(request, job_id):

job = get_object_or_404(Job, pk=job_id)

form = ApplicationForm(request.POST, request.FILES)

if form.is_valid():

app = form.save(commit=False)

app.applicant = request.user
 app.job = job

app.save()

return redirect('application_success')

• Uses Django’s file upload handling

• Validates file type/size (can be extended)

• Associates job & applicant efficiently

Template Inheritance for DRY HTML

<!-- base.html -->

<!DOCTYPE html>

<html>

<head>{% block head %}{% endblock %}</head>

<body>

{% block content %}{% endblock %}

</body>

</html>

<!-- job_list.html -->

{% extends "base.html" %}

{% block content %}

<h2>Available Jobs</h2>

{% for job in jobs %}

<p>{{ job.title }} at {{ job.company }}</p>

{% endfor %}

{% endblock %}

• Reduces repetition

• Layout consistency

• Easy UI maintenance
Efficiency Considerations:

• Pagination for large job lists

• Bulk inserts using bulk_create for importing jobs
• Select_related() to optimize JOINs in application listings
• CSRF protection for all forms
• Query caching for heavy filters (future scope)

5.1 User Documentation

Job Seeker Flow:

1. Register as Candidate
2. Complete profile and upload resume
3. View jobs and apply
4. Track status in dashboard

Employer Flow:

1. Register as Employer
2. Post new jobs
3. View applications
4. Download resumes

Admin Flow:

1. Login to /admin
2. Manage Users, Jobs, and Applications
3. Remove spam, reset credentials, and monitor activity

6.1 Test Cases with Image Descriptions

Test Case Scenario Input Expected Output
TC01 Candidate registration Valid user data Success, redirect to login
TC02 Employer posts job Job form Job listed in job board
TC03 Apply with resume Upload file Application saved, success msg
TC04 Admin deletes user Click “Delete” User removed
TC05 Search job with keyword "Python" Filtered job list

Screenshots:

• Registration form
• Dashboard (Employer/Candidate)
• Job list page
 • Application submission success
• Admin panel view

7. Conclusion
The Online Job Management System successfully implements the full recruitment lifecycle using
Django. It covers multi-role access, job interaction, and admin management. Its modularity
ensures future scalability, such as:

• Adding real-time notifications

• Enhancing resume filtering using NLP
• Integrating with LinkedIn/GitHub for profile import
• Deploying on AWS/Heroku for scalability

This project provides a real-world foundation in building full-stack Django applications with
robust architecture and clean coding practices.