Stop losing track of where you applied. A clean, multi-user web app to log every job application, set follow-up reminders, and visualize your job search progress — all in one place. Built entirely with Python using OOP principles, SQLite, and Streamlit.
🔗 https://abhishek-job-tracker.streamlit.app/
https://abhishek-job-tracker.streamlit.app/
Register a free account and start tracking your job applications instantly — no setup required.
| Layer | Technology |
|---|---|
| Frontend | Streamlit (Python web UI) |
| Backend | Pure Python (OOP architecture) |
| Database | SQLite via Python built-in sqlite3 |
| Auth | SHA-256 hashing via hashlib |
| Analysis | Pandas |
| Charts | Plotly |
No Django, Flask, or external auth libraries used. Everything is built from scratch using Python OOP concepts.
job_tracker/
├── app.py # Streamlit entry point + auth gate + routing
│
├── database/
│ ├── database.py # SQLite CRUD for job applications
│ ├── models.py # JobApplication dataclass (OOP: data model)
│ ├── user_database.py # SQLite CRUD for users + SHA-256 hashing
│ └── user_model.py # User dataclass (OOP: data model)
│
├── services/
│ ├── application_service.py # Business logic for job applications
│ ├── analytics_service.py # Pandas + Plotly chart generation
│ ├── auth_service.py # Login/register business logic + validation
│ └── reminder_service.py # Follow-up date logic
│
├── ui/
│ ├── auth.py # Login & Register Streamlit forms
│ ├── dashboard.py # Home overview page
│ ├── add_application.py # Add new application form
│ ├── applications.py # List, search, edit, delete applications
│ ├── reminders.py # Follow-up reminders page
│ └── statistics.py # Analytics and charts page
│
├── utils/
│ ├── constants.py # All fixed values (status options, page names)
│ ├── helpers.py # Date utilities
│ └── validation.py # Input validation functions
│
└── requirements.txt
- Register — create an account with a username and password
- Login — sign in securely; passwords are stored as SHA-256 hashes (never plain text)
- Logout — one-click logout from the sidebar
- Per-user data — every user only sees and manages their own job applications
- Validation — username must be 3–20 alphanumeric characters; password minimum 6 characters
- Total applications count
- Breakdown by status: Applied, Interview, Offer, Rejected
- Interview Rate and Offer Rate percentages
- Count of urgent follow-up reminders
- Status pie chart and bar chart
- Recent 5 applications table
- Form with required fields: Company, Role, Status, Applied Date
- Optional fields: Location, Salary Range, Follow-up Date, Notes
- Input validation before saving
- Confetti animation on successful save
- Full searchable, filterable table of all your applications
- Search by company name or role
- Filter by status (Applied / Interview / Offer / Rejected)
- Edit any application inline with a form
- Delete any application with a confirmation prompt
- Overdue — applications whose follow-up date has passed
- Due Today — applications due for follow-up today
- Upcoming — applications due within the next few days
- Color-coded cards (red = overdue, yellow = today, blue = upcoming)
- Key metrics: Interview Rate, Offer Rate, Rejection Rate
- Status distribution pie chart
- Status bar chart
- Applications per month trend line
- Job search funnel (Applied → Interview → Offer)
- Status breakdown table with counts and percentages
This project is structured in 4 layers — a clean separation of concerns:
UI Layer (Streamlit)
↓ calls
Service Layer (business logic)
↓ calls
Database Layer (SQL)
↓ reads/writes
SQLite File
| Concept | Where | Explanation |
|---|---|---|
@dataclass |
User, JobApplication |
Auto-generates __init__, __repr__, __eq__ |
| Encapsulation | UserDatabase, Database |
All SQL hidden behind clean method names |
| Composition | AuthService has-a UserDatabase |
One class uses another class internally |
| Class Methods | User.from_row(), JobApplication.from_row() |
Alternative constructors that build from DB rows |
| Dependency Injection | All service constructors | Objects receive dependencies instead of creating them |
| Private Methods | _hash_password(), _connect() |
Internal helpers with underscore prefix |
| Tuple Returns | AuthService.register_user() → (bool, str) |
Clean pattern for "success + message" |
1. App loads → check st.session_state["user_id"]
↓
Not found → show Login/Register page → st.stop()
↓
User registers → password hashed with SHA-256 → saved to users table
↓
User logs in → entered password hashed → compared to stored hash
↓
Match → store user_id and username in st.session_state
↓
App reruns → user_id found → normal app shown
↓
Logout → st.session_state.clear() → back to step 1
Password Security:
- Passwords are never stored as plain text
- Python's built-in
hashlib.sha256()converts"password"→"b94d27b9..." - This is a one-way function — even if the database is stolen, passwords cannot be reversed
Data Isolation:
- Every job application has a
user_idcolumn - Every SQL query has
WHERE user_id = ? - Users can never see or modify each other's data
| Column | Type | Description |
|---|---|---|
| id | INTEGER PK | Auto-assigned by SQLite |
| username | TEXT UNIQUE | Login name |
| password_hash | TEXT | SHA-256 hash of password |
| created_at | TEXT | Registration timestamp |
| Column | Type | Description |
|---|---|---|
| id | INTEGER PK | Auto-assigned by SQLite |
| company | TEXT | Company name |
| role | TEXT | Job title |
| location | TEXT | City or remote |
| salary | TEXT | Salary range as text |
| status | TEXT | Applied / Interview / Offer / Rejected |
| applied_date | TEXT | YYYY-MM-DD format |
| followup_date | TEXT | YYYY-MM-DD format |
| notes | TEXT | Free text notes |
| created_at | TEXT | Insert timestamp |
| updated_at | TEXT | Last edit timestamp |
| user_id | INTEGER | Foreign key → users.id |
git clone https://github.com/abhisheksinghcodebase/Job_tracker.git
cd Job_trackerpip install -r requirements.txtstreamlit run app.pyThe app opens at http://localhost:8501
The SQLite database file is created automatically at database/job_tracker.db on first run — no setup required.
SQLite does NOT persist on Streamlit Community Cloud.
Streamlit Cloud runs your app on a server with an ephemeral (temporary) filesystem. Every time the app restarts (after inactivity, redeployment, or server maintenance), the
job_tracker.dbfile is permanently deleted and all user accounts and application data are lost.For production use, replace SQLite with an external database such as:
- Supabase — free PostgreSQL (recommended)
- MongoDB Atlas — free NoSQL
- PlanetScale — free MySQL
- Push code to GitHub (already done)
- Go to share.streamlit.io
- Connect your GitHub account
- Select repository:
abhisheksinghcodebase/Job_tracker - Main file:
app.py - Click Deploy
streamlit>=1.32.0 # Web UI framework
pandas>=2.0.0 # Data manipulation and DataFrames
plotly>=5.18.0 # Interactive charts
All other modules (sqlite3, hashlib, dataclasses, datetime) are Python built-ins — no extra installation needed.
Built by Abhishek Singh — a learning project to practice Python OOP, SQLite, and Streamlit.