Job applications are grueling work. And if, like me, you’ve got constraints like “must be visa-sponsored”, it gets worse fast: needing sponsorship turns normal job hunting into time-wasting with extra steps. You can spend ages reading walls of text just to figure out if a role is even viable, retyping the same info into yet another ATS, and then tracking it all in a spreadsheet like it’s your second job.

To solve this, I built JobOps: DevOps thinking applied to job hunting. I’m documenting it here, as a showcase of my work, and in hopes that this flow will inspire other.

filling job applications is grueling work

It’s the most thankless work I’ve ever had to do. For a single application, here’s the steps I used to had to do, and in fact I did, for some eighty applications when finding my placement in December 2023:

step 1; find the jobs

Searching for jobs themselves is a surprisingly annoying process. you’ve got multiple sources, so LinkedIn, Indeed, Gradcracker, and I found a new one that’s especially relevant to me called ukvisajobs.com (more about these guys later). Each of these sources have a different UI, and they report different things about the role. eg Gradcracker mentions details about the employer too, but in LinkedIn, this is quite hidden away. What I’m saying is, parsing the information out of these job walls of text to decipher if this is a job worth applying to takes a while.

step 2; fill in the application

tailoring the cv

To apply, you almost always need a tailored CV. This is where my old process was especially lacking. I have a custom GPT that knows all about me (instructions here).

So I paste in a job description I just found, it spits out a “summary” that I can use in that CV. To build this CV, I go to rxresu.me, my resume builder of choice, update the summary, save it, and then upload it to the job platform. This means only one section is being tailored for the job description, but it is a tailored CV, so it’s better than nothing.

filling the application

This is the hard part. It’s menial work. It’s the same thing, over and over and over again. Companies ask for a CV, and then you’ve gotta submit the same information into the ATS, but typed out this time. It’s slow, it’s arduous, and I found that no amount of scripts and paste-able chunks made this process any less annoying.

And no, LinkedIn or Indeed’s easy apply features don’t count. Every single posting has a million applications, and you can’t make yourself seen in an ocean of garbage.

step 3; tracking the applications

I’ve been using a Notion page as my “source of truth” for tracking my applications, placement, and now the graduate applications. To fill in the row, I need to go back to the GPT, get the job title, company, location, salary, and all other details, and one by one copy paste them into Notion.

if it sounds like im complaining, i am

All of this is for a simple application, one where you have the answers to all the questions. If you need to make it customised for some reason, say they ask why you’re interested in the role, now you need to have a back and forth with the AI, come up with something you’re happy with, and then paste that in too. I know I sound like I’m whining, and I am, but all in, this is a super annoying process and it’s easily 20 minutes per application.

Even with all this, I still had problems. I had cases where I forgot which job I applied to, because the link that I saved in Notion now said “job not available”, and I didn’t have a PDF saved of which CV I applied with. I had to go into a few interviews, and ask the recruiter which job this interview was for. Not a great look.

the solution is DevOps, but for jobs: JobOps

I realised i’ve got chunks of things that I have to do. Find a job, make a tailored cv, add this tailored CV and other related content to the ATS, track this job as applied in Notion. If you know anything about me, you know I’m big on automation, and each of these chunks can be automated in isolation. So then it’s almost definitely possible to make an orchestrator to make all these individual pieces come together into a full system.

The final solution is a linear flow for each job with a source, a processing step, and a distinct completion stage. This is quite similar to how a DevOps pipeline works in real life, hence the name.

step 1; find the jobs (the extractors)

Finding jobs is easy. Gradcracker, LinkedIn, and Indeed.

JobSpy

I found a library that does LinkedIn and Indeed already. JobSpy. Still maintained, still working. And since I’m not scraping at a mass scale, and because I have a residential IP address, they’re not very likely to block me. Just need to translate the output data into a unified format, and bingo!

Gradcracker

I also really wanted Gradcracker, so I wrote a custom Crawlee scraper for this. It builds search URLs, sorted by newest first, and fetches all the jobs for that search term.

For each page, it:

• Waits for the job cards to load.

• Scrapes basic fields from each card: title, employer, employer URL, discipline, deadline, salary, location, degree required, and start date.

• Queues each job’s detail page for deeper scraping.

On each job page it:

• Waits for the main content block (.body-content).

• Saves the full description text.

• Looks for the Apply button and clicks it to capture the final application URL.

  • Handles both popup windows and same-tab redirects.

  • Waits for the URL to stabilize before recording it.

In doing so, we can scrape a vast number of jobs from Gradcracker, along with the description, and all related metadata. One interesting bit is that the crawler is launched through Camoufox to look more like a real browser. Camoufox’s humanize feature is the coolest thing I’ve ever seen.

UKVisaJobs

This platform charges 6 pounds a month. I didn’t feel like paying this amount, so I found a way through by reverse engineering their public facing API.

This extractor works by logging into my.ukvisajobs.com to capture the auth token and cookies needed for its private jobs API, then using that session to pull paginated job data. The extractor caches the session on disk and automatically refreshes it when it expires, so most requests skip the browser login. It maps the API fields into the app’s job schema, writes results to a Crawlee‑style dataset, and the orchestrator reads that dataset, de‑dupes jobs, and optionally fills in missing/short descriptions by fetching the job page directly.

step 2; fill in the application

Okay, so we’ve got a 2 steps in this one step. Make a tailored CV, and fill in the details into the ATS.

easy part first: the autofill

There’s a million different browser extensions that claim to fill in your details into ATS systems. I tested at least a dozen before I landed on by far the most reliable, most widely supported, and fastest one: Simplify. Just do the copy pasting once into the browser extension, and it’s gonna pop up the next time you’re on an ATS page. Give it a second, and it’s gonna work it’s magic. It’s not perfect, but it’s still significantly better than doing it by hand, because it gets the boring questions (im looking at you workday’s experience section) right every time, and the ones it misses are the more interesting questions anyway.

generating the cv

We need content for the CV, and then we need to make the CV itself. Because I wanted to stay as close as possible to my original workflow, I chose to automate the PDF generation using a playwright script instead of generating it in code. The idea behind it is that I know this format works. In supported ATSes, if I use this format to try and autofill, the system can recognise the fields correct, and fill them in. This gives me confidence that the formatting of the generated PDF can be read by these systems. I remember having made a CV in Figma a while ago, and how it was never picked up by any ATS system ever, which is an avoidable footgun I’d like to avoid.

Reactive Resume uses a json file to generate it’s PDFs. This json file has all information about the formatting, the theme, the sections, and the layout and content of these sections. Another win for AI, because large language models are good at generating text. I need to tailor as much as I can, while still staying true to the original base.json I downloaded, the one that represents my CV.

I chose to have AI edit these sections, with custom instructions for each:

• the summary

• the headlining text under my name

• the keywords at the end

• which projects to include

Once we have a customised base.json file, we can use this to make a new PDF file, with the playwright script I mentioned earlier.

step 3; tracking the applications

The orchestrator shows a set of buttons to view the resume, download the resume (with an ATS friendly filename), and to mark as applied.

Now that I’ve been getting into self hosting things on my home server, I’ve realised I can do quite a few powerful things with it, things like selfhosting n8n. JobOps sends a webhook event when a job is “marked applied” in the UI. This is captured by n8n, which can extract all the information I used to manually extract from each job posting AND post it to the Notion database.

other fun bits

UKVisaJobs, without the paywall

UKVisaJobs is a useful source if you’re filtering hard for sponsorship, but it’s also paid if you want proper access to the listings. I didn’t want “pay monthly, use a separate UI, then copy details back into my workflow” to be part of my process, so I surfaced the UKVisaJobs feed inside JobOps as a simple search page. It’s there because it makes my pipeline better, and as a side effect, it’s public, so if it’s useful to you too, you can use it: https://jobops.dakheera47.com/ukvisajobs

visa sponsors directory

One of my non-negotiables for graduate roles is visa sponsorship, and “this role offers sponsorship” is the single most unreliable sentence on the internet. So JobOps has a dedicated page for it: /visa-sponsors. It’s basically a fast, searchable wrapper around the UK Home Office’s Register of licensed sponsors (workers), which is published as a big CSV and updated constantly.

Instead of downloading an 11MB spreadsheet and Cmd+F-ing, I can search an employer name and immediately see what matters: where they’re based, their sponsor type/rating, and which route they’re licensed for (for example “Skilled Worker” vs other worker routes). That means I can sanity-check a posting in seconds: if the company isn’t on the register (or only appears for routes that don’t help me), it’s an instant skip, and I don’t waste time tailoring a CV for a job that was never viable.

concluding

This some ~30k lines of code means that my job application process now looks like this:

1. Find a job (from an already scored by relevance) list and generate a tailored CV for it

2. Fill in the application with Simplify, and Mark Completed

All of this efficiency gain means I can fill out 3-4 applications in 20 minutes, all while keeping a balance of automated, but still with a human in the loop.

Now when I get a reply from a recruiter, I don’t have to play detective anymore. Every application is stored as a complete snapshot: the exact job description text I saw at the time, the source link I applied through, the timestamp of when I marked it as applied, and the precise CV PDF (and underlying resume JSON) that JobOps generated for that role. So if someone emails me weeks later, I can open that entry and instantly see what the role actually was, what the company asked for, and what version of me I presented to them, which means I’ll never repeat the “sorry, which job is this interview for?” disaster from last time.

I built JobOps because this process is broken, and I refuse to lose hours to copy-paste theatre. But I’m not trying to turn it into another “sign up and hand over your data” SaaS either. If it’s going to exist, it should be something you can self-host, inspect, and control, so I’ve documented the setup and made it easy to deploy. https://github.com/DaKheera47/job-ops. There’s also a read-only demo running at jobops.dakheera47.com if you want to poke around my applications