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.
