Finding a job is already stressful. Finding the right job is even harder.
Most students and fresh graduates upload their CV everywhere, apply to random jobs, wait for replies, and then get ignored by HR like their resume went into a black hole. So I wanted to build something that feels useful, fun, and practical at the same time.
That is how Rizq.ai was created.
Github: https://github.com/ctrlaltimran/AI-Smart-Job-Finder-Web-
Rizq.ai is an AI powered job matching web app that reads a user’s resume, understands the skills from it, and then shows the best matched jobs from our own job database. It also includes an admin panel where a job administrator can add new jobs, manage existing jobs, and keep the job data clean.
The idea was simple:
Upload CV, let AI understand it, and match it with the most relevant jobs.
Why I Created Rizq.ai
I created Rizq.ai as a portfolio project to show how AI can be used in real world hiring and job search systems.
Instead of making a basic job listing website, I wanted to build something more interactive. A normal job portal just displays jobs. Rizq.ai does more than that. It reads the resume, extracts useful information, compares it with available jobs, and gives a match score.
This makes the experience feel smarter and more personal.
The goal was to build a project that includes:
Resume upload
PDF text extraction
AI based skill matching
Job recommendation system
Admin login
Job posting system
Local job database
Map style job view
Clean frontend UI
FastAPI backend
It is not just a design project. It is a working full stack AI based web application.
The Main Concept
The app works in a very simple flow.
A user uploads their resume. The backend extracts text from the PDF. Then the app checks the skills, keywords, and job related information inside the resume. After that, it compares the resume data with the available jobs and shows the best matched results.
The user does not need to search manually through hundreds of jobs.
Rizq.ai does the filtering for them.
Main Features
Here are the main features I added in the project:
1. Resume Upload and Parsing
Users can upload their CV or resume in PDF format. The backend reads the file and extracts the text.
This makes the app understand what skills, experience, and keywords are inside the resume.
Example backend logic:
def extract_resume_text(file):
text = ""
reader = PdfReader(file)
for page in reader.pages:
page_text = page.extract_text()
if page_text:
text += page_text + "\n"
return text
This is one of the most important parts of the project because the job matching depends on resume content.
2. AI Based Job Matching
After extracting resume text, the app compares it with job data.
Each job has skills, title, company, location, salary, and description. The app checks how many skills from the resume match the job requirements.
A simplified version of the matching logic looks like this:
def calculate_match_score(resume_text, job_skills):
resume_text = resume_text.lower()
matched_skills = []
for skill in job_skills:
if skill.lower() in resume_text:
matched_skills.append(skill)
score = int((len(matched_skills) / len(job_skills)) * 100)
return {
"score": score,
"matched_skills": matched_skills
}
This helps the app show only the most relevant jobs to the user.
3. Own Job Data Only
One of the major changes I made was removing random integrated job data.
At first, using outside or demo data created confusing results. For example, if someone uploaded a resume for a Dubai team lead role, the app could show jobs from unrelated countries or irrelevant fields.
So I changed the system.
Now the app only uses our own job database. This keeps the data controlled, clean, and useful for demo purposes.
For the portfolio version, I created hundreds of fake CS related jobs for Karachi so the app can properly showcase matching results.
Example job data:
{
"title": "Frontend Developer",
"company": "Karachi Tech Studio",
"location": "Karachi",
"salary": "PKR 90,000 - 140,000",
"skills": ["HTML", "CSS", "JavaScript", "React"],
"description": "We are looking for a frontend developer who can build modern responsive interfaces.",
"apply_url": "https://ctrlaltimran.com"
}
This makes the app better for presentations, testing, and portfolio showcasing.
4. Admin Login and Job Posting
I also added a separate admin panel for the job administrator.
The admin can log in, view all current jobs, and post new jobs. This makes the app feel more like a real job platform instead of just a static project.
The admin panel is separate from the homepage, so the user experience stays clean.
Example route structure:
@app.get("/")
def home():
return FileResponse("frontend/index.html")
@app.get("/admin")
def admin_page():
return FileResponse("frontend/admin.html")
Admin authentication is handled with environment variables so login details do not have to be hardcoded in the app.
Example:
ADMIN_USERNAME = os.getenv("ADMIN_USERNAME", "admin")
ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin123")
For real deployment, the password should always be changed.
5. Job Map View
I also added a map style section where matched jobs appear visually. The goal was to make the result page feel more modern and interactive.
Instead of just showing job cards, the user can also see a location based view of nearby jobs.
For the demo version, the jobs are mostly Karachi based, so the map view gives a quick visual feel of where opportunities are located.
6. Resume Summary Preview
Another useful feature is the resume summary preview.
After a resume is uploaded, the app shows a short summary or important lines from the resume. This helps the user understand what the system extracted from their CV.
This also makes the app feel more transparent because the user can see what information is being used for matching.
Tech Stack Used
I used a simple but powerful stack for this project.
Frontend: HTML, CSS, JavaScript
Backend: Python FastAPI
Resume Parsing: PDF text extraction
Data Storage: Local JSON file
Admin Panel: Custom HTML, CSS, JS
Styling: Modern dark UI
Hosting Ready: Can be deployed with Python hosting or Docker based platforms
FastAPI was a good choice because it is lightweight, fast, and easy to connect with frontend APIs.
How the Backend Works
The backend handles resume upload, job loading, job matching, and admin job posting.
A simplified upload route looks like this:
@app.post("/api/match-jobs")
async def match_jobs(resume: UploadFile = File(...)):
resume_text = extract_resume_text(resume.file)
jobs = load_jobs()
matched_jobs = []
for job in jobs:
result = calculate_match_score(resume_text, job["skills"])
if result["score"] > 0:
job["match_score"] = result["score"]
job["matched_skills"] = result["matched_skills"]
matched_jobs.append(job)
matched_jobs = sorted(
matched_jobs,
key=lambda job: job["match_score"],
reverse=True
)
return {
"resume_summary": resume_text[:500],
"jobs": matched_jobs[:20]
}
This route receives the resume, extracts the text, checks job matches, sorts them by score, and sends the best results back to the frontend.
How the Admin Job Posting Works
The admin can add a new job from the dashboard. The new job gets saved into the jobs JSON file.
Example logic:
@app.post("/api/admin/jobs")
async def add_job(job: JobCreate, user=Depends(require_admin)):
jobs = load_jobs()
new_job = {
"id": len(jobs) + 1,
"title": job.title,
"company": job.company,
"location": job.location,
"salary": job.salary,
"skills": job.skills,
"description": job.description,
"apply_url": "https://ctrlaltimran.com"
}
jobs.append(new_job)
save_jobs(jobs)
return {
"success": True,
"message": "Job added successfully",
"job": new_job
}
This makes the admin panel useful because new jobs can be added without editing code manually.
UI and Design Direction
For the interface, I wanted it to feel modern, clean, and slightly fun. Since the project name is Rizq.ai, the branding has a desi tech feeling.
The UI uses a dark theme with cards, soft gradients, smooth sections, and a professional layout.
The homepage focuses on the user action:
Upload resume
Analyze resume
Show best matched jobs
Apply through the given link
The admin dashboard is separate and organized so the job administrator can manage jobs without disturbing the main user flow.
Security and Data Handling
Since this project includes resume uploads and admin access, I also focused on basic safety.
The app is designed so that:
Resume text is processed for matching
Admin panel requires login
Job data comes only from our own database
External random job sources are removed
Admin credentials can be stored using environment variables
Apply links are controlled
For a production level version, I would improve it further with:
Database storage
Hashed passwords
User accounts
Secure file handling
Rate limiting
Real job APIs
Cloud storage
Admin activity logs
But for a portfolio project and demo app, the current structure is clean and practical.
What I Learned From This Project
This project helped me understand how a real AI powered job system could work.
I worked on:
Backend API planning
Resume parsing
Job matching logic
Frontend result rendering
Admin dashboard structure
Data organization
Local app running
Deployment planning
UI improvements
Debugging Python environments
One of the biggest lessons was that data quality matters a lot. If the job data is messy, the AI matching also feels messy. That is why I removed random integrated jobs and moved toward our own controlled job database.
Good data makes the app feel smarter.
Future Improvements
There are many things I can add in the future.
Some possible improvements are:
Real database instead of JSON
Better AI based resume understanding
Skill gap suggestions
Resume improvement tips
Job filters by salary and location
User login
Saved jobs
Email job alerts
Company dashboard
Real Google Maps integration
Application tracking
Better admin analytics
I also want to make the matching system more advanced, where the app does not only check exact skills but also understands related skills. For example, if a resume has React, it should also understand that the user may be suitable for frontend roles.
Final Thoughts
Rizq.ai is a fun and practical AI job matcher that turns a resume into job opportunities.
The goal was not just to build another job board. The goal was to create a smarter job matching experience where users can upload their CV and instantly see the jobs that actually fit them.
It combines AI logic, resume parsing, job data, admin management, and a clean user interface into one complete project.
This project is part of my portfolio on ctrlaltimran.com.
If anyone wants the source code, wants to collaborate, or wants a similar AI based web app for their own idea, they can contact me through my website.
Project Name: Rizq.ai
Category: AI Job Matcher
Built By: Ctrl Alt Imran
Website: ctrlaltimran.com
Rizq.ai makes job hunting feel less random and more intelligent.