A job search platform that aggregates listings from Remotive and RemoteOK into one normalized feed. Public browsing, search, and filters work without an account; registered users can save jobs and track application status from a dashboard.
jobflow/
βββ backend/ Flask API (job aggregation, auth, saved jobs) β deploy to Render
βββ frontend/ React + Vite SPA β deploy to Vercel
- The Flask backend is the only thing that talks to Remotive and RemoteOK. It fetches
both APIs, normalizes them into one job schema (title, company, location, remote,
tags, job_type, experience_level, apply_url, etc.), merges them, and caches the
result in memory for
JOB_CACHE_TTLseconds so the upstream APIs aren't hit on every request. job_type: internshipandexperience_level: entry_levelare inferred from keywords in the title/description (e.g. "intern", "junior", "entry level") since neither upstream API exposes these as clean fields.- The frontend never calls Remotive/RemoteOK directly β only the Flask API.
- Auth is stateless JWT (Flask-JWT-Extended), not Supabase Auth. Supabase here is just a hosted Postgres database; the connection string is all that's used.
- When a user saves a job, the backend stores a snapshot of that job's normalized data alongside the save record, so the dashboard renders saved jobs without needing to re-query the external APIs (which don't support lookup-by-id).
cd backend
python3 -m venv venv && source venv/bin/activate
pip install -r requirements.txt
cp .env.example .env # then edit DATABASE_URL / JWT_SECRET_KEY as needed
python run.py # runs on http://localhost:5000For local development you can leave DATABASE_URL unset β it falls back to a local
SQLite file, which is fine for trying things out before you have Supabase set up.
Tables are created automatically on startup (db.create_all()), so no migration
step is needed for a first run.
cd frontend
npm install
cp .env.example .env # VITE_API_URL=http://localhost:5000
npm run dev # runs on http://localhost:5173- Create a project at supabase.com.
- In Project Settings β Database, copy the Connection pooling URI (port 6543) β this is built for serverless/short-lived connections like Render's.
- Set that as
DATABASE_URLin the backend's environment. The app will create theusersandsaved_jobstables on first boot.backend/db/schema.sqlis provided as a reference/fallback if you'd rather run the SQL yourself. - Nothing else is required β no Supabase Auth setup, no RLS policies β since the Flask backend handles auth and every query is scoped to the authenticated user at the application layer.
- Push this repo to GitHub and create a new Web Service on Render pointed at
backend/(or use the includedrender.yamlas a Blueprint). - Build command:
pip install -r requirements.txt. Start command:gunicorn wsgi:app. - Set environment variables:
DATABASE_URL(Supabase pooling URI),JWT_SECRET_KEY(long random string),FRONTEND_ORIGINS(your Vercel URL, comma-separated if more than one), and optionallyJOB_CACHE_TTL.
- Import the repo into Vercel, set the project root to
frontend/. - Framework preset: Vite. Build command
npm run build, output directorydist. - Set
VITE_API_URLto your Render backend URL (no trailing slash). vercel.jsonis included so client-side routes (e.g./jobs/:id) resolve correctly on refresh/direct link.
After both are deployed, update the backend's FRONTEND_ORIGINS to include the
real Vercel URL (CORS is locked down to that list).
| Method | Path | Auth | Description |
|---|---|---|---|
| GET | /api/jobs |
none | List jobs. Query params: q, remote, internship, entry_level, tech (comma-separated), location, page, per_page |
| GET | /api/jobs/meta |
none | Distinct tags/locations currently available, for filter UIs |
| GET | /api/jobs/<job_id> |
none | Single normalized job |
| POST | /api/auth/register |
none | { email, password, name? } β { token, user } |
| POST | /api/auth/login |
none | { email, password } β { token, user } |
| GET | /api/auth/me |
JWT | Current user |
| GET | /api/dashboard/saved-jobs |
JWT | List saved jobs (optional ?status= filter) |
| POST | /api/dashboard/saved-jobs |
JWT | { job_id } β saves a job (snapshots current data) |
| PATCH | /api/dashboard/saved-jobs/<id> |
JWT | { status } β one of saved, applied, interview, rejected |
| DELETE | /api/dashboard/saved-jobs/<id> |
JWT | Remove a saved job |
| GET | /api/dashboard/analytics |
JWT | { total_saved, by_status } |
- The external job APIs are not paginated server-side in a way that supports deep lookups by id, so the backend fetches the full list per provider and filters/ paginates in memory. This is fine at Remotive/RemoteOK's current listing volumes but wouldn't scale to much larger sources without moving to a periodic sync job that writes into Postgres.
job_typeandexperience_levelare keyword-inferred, not provided upstream, so they won't be perfectly accurate for every listing.db.create_all()is used instead of a migration framework for simplicity. For schema changes after launch, consider adding Flask-Migrate (Alembic).