Rizq.ai: An AI Job Matcher

Finding a job is stressful. Finding the right job is even harder.

Most students and fresh graduates upload their CV everywhere, apply to random jobs, and then wait while HR ignores them like their resume fell into a black hole. I wanted to build something useful, practical and a little fun. That is how Rizq.ai started.

Rizq.ai is an AI powered job matching web app. It reads a resume, understands the skills in it, and shows the best matching jobs from its own job database. It also has an admin panel where a job administrator can add new jobs, manage existing ones and keep the data clean.

The idea is simple: upload your CV, let AI understand it, and get matched with the most relevant jobs.

Why I built it

I built Rizq.ai as a portfolio project to show how AI can be used in real hiring and job search systems.

A normal job portal just lists jobs. Rizq.ai reads the resume, pulls out the useful information, compares it with the jobs available and gives each one a match score. That makes the whole thing feel smarter and more personal.

The project covers:

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. It is a working full stack web app.

The main concept

The flow is simple. A user uploads a resume, the backend extracts the text from the PDF, and the app checks the skills, keywords and job related details inside it. Then it compares that with the available jobs and shows the best matches.

Nobody has to scroll through hundreds of listings. Rizq.ai does the filtering for them.

Main features

1. Resume upload and parsing

Users upload their CV as a PDF. The backend reads the file and extracts the text, so the app knows which skills, experience and keywords are inside.

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 all the matching depends on what is in the resume.

2. AI based job matching

Each job has skills, a title, company, location, salary and description. The app checks how many of the job's required skills appear in the resume. A simplified version of the logic:

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
    }

3. Our own job data only

One big change I made was removing random integrated job data. Outside or demo data gave confusing results. Someone uploading a resume for a team lead role in Dubai could get jobs from unrelated countries or fields.

So now the app only uses its own job database. The data stays controlled, clean and useful. For the portfolio version I created hundreds of sample CS jobs in Karachi so the matching can be shown properly.

{
  "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"
}

4. Admin login and job posting

There is a separate admin panel where the job administrator can log in, see all current jobs and post new ones. It lives apart from the homepage, so the user experience stays clean.

@app.get("/")
def home():
    return FileResponse("frontend/index.html")

@app.get("/admin")
def admin_page():
    return FileResponse("frontend/admin.html")

Admin login details come from environment variables, so nothing is hardcoded:

ADMIN_USERNAME = os.getenv("ADMIN_USERNAME", "admin")
ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin123")

For a real deployment, the password should always be changed.

5. Job map view

Matched jobs also show up on a map style view, so users can see where the opportunities are instead of only reading cards. Since the demo jobs are mostly in Karachi, it gives a quick feel for what is nearby.

6. Resume summary preview

After upload, the app shows a short summary of the resume. Users can see exactly what was pulled from their CV, which makes the matching feel transparent.

Tech stack

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: Any Python host or Docker based platform

FastAPI was a good fit because it is light, fast and easy to connect to a frontend.

How the backend works

The backend handles resume upload, loading jobs, matching and admin job posting. A simplified version of the matching route:

@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]
    }

It receives the resume, extracts the text, scores every job, sorts them and sends the best results back to the frontend.

How admin job posting works

The admin adds a job from the dashboard and it gets saved into the jobs JSON file:

@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
    }

New jobs can be added without touching the code.

UI and design

I wanted the interface to feel modern, clean and a little playful. The name Rizq.ai gives it a desi tech feel. It uses a dark theme with cards, soft gradients and a clear layout, and the homepage is built around one flow:

Upload resume
Analyze resume
Show best matched jobs
Apply through the given link

Security and data handling

Because the app handles resume uploads and admin access, I kept the basics in place:

Resume text is processed only for matching
Admin panel requires login
Job data comes only from our own database
External random job sources are removed
Admin credentials can live in environment variables
Apply links are controlled

For a production version I would add:

Database storage
Hashed passwords
User accounts
Secure file handling
Rate limiting
Real job APIs
Cloud storage
Admin activity logs

What I learned

This project taught me how a real AI powered job system could work, from API planning and resume parsing to matching logic, rendering results, structuring an admin dashboard and debugging Python environments.

The biggest lesson: data quality matters a lot. Messy job data makes the AI matching feel messy too. Moving to a controlled job database made the whole app feel smarter.

What is next

Real database instead of JSON
Better AI resume understanding
Skill gap suggestions
Resume improvement tips
Filters by salary and location
User login and saved jobs
Email job alerts
Company dashboard
Real Google Maps integration
Application tracking
Better admin analytics

I also want the matching to understand related skills, not just exact ones. If a resume mentions React, the app should know the person could be a good fit for frontend roles in general.

Final thoughts

Rizq.ai turns a resume into real job matches. The goal was not another job board, but a smarter way to find the jobs that actually fit you. It brings together AI logic, resume parsing, job data, admin tools and a clean interface in one complete project.

If you want the source code, want to collaborate, or want a similar AI web app for your own idea, get in touch.

Want something like this built?

I build web apps, AI tools and custom software. Tell me your idea.

Let’s talk