I had just finished a grueling round of final interviews with a startup that seemed perfect. They ghosted me. No email, no closure, just silence. That was the thirty seventh application I had filled out by hand. My spreadsheet was a graveyard of “no response” rows. I was exhausted. My fingers knew the keyboard shortcut for pasting my address into another badly designed form. I could recite my own LinkedIn summary from memory. Something had to change.
So I did what any sleep deprived software developer would do. I opened a new Python file and started writing scripts to automate the worst parts of my job search. This is the story of what I built, how it worked, the ethical lines I nearly crossed, and the surprising outcome that had very little to do with the code.
The First Script: Scraping Job Boards
My initial idea was simple: instead of visiting five job boards every morning and clicking through pages of listings, I would write a script to pull the newest posts and dump them into a single file. I used Python’s requests library and BeautifulSoup to scrape Indeed, a few niche tech boards, and a local startup job aggregator.
It broke within two hours. Indeed served dynamically loaded content that my static parser couldn’t see. The startup aggregator had a Cloudflare bot check that returned a 403 the moment my script knocked without a proper user agent. I felt foolish. I had underestimated how aggressively sites guard their listings from automated access.
I regrouped. For Indeed, I switched to using their public RSS feeds for certain search queries, which gave me clean XML without any scraping tricks. For the other boards, I used Selenium with a headless Chrome instance, adding random delays between requests and a rotating set of legitimate user agent strings. I ran the script once a day, early in the morning, and limited it to the first three pages of results. My goal was not to hammer anyone’s server; I just wanted to see what a human would see in a few minutes of browsing, collected in one place.
The output was a CSV file with job title, company, location, a short description snippet, and a direct link to the application page. On day one, it gathered 43 listings that I would have missed. I spent the morning reading through them, saved a dozen, and felt a small but genuine sense of relief. I had clawed back maybe 45 minutes of mindless scrolling.
Automating the Application Forms
The bigger pain was filling out the applications themselves. Every company seemed to use a different applicant tracking system, each with its own way of asking for the same information. First name, last name, email, phone, resume upload, cover letter box, equal opportunity questions. Sometimes the same company would make me re-enter everything after I had already uploaded a resume that contained the exact same data.
I built a second script using Selenium that could populate these forms automatically. I created a configuration file with my standard details and a mapping for common field names and IDs. The script looked for input fields by label text or placeholder values and filled them with my saved information. It uploaded my resume file when it detected a file input. It clicked “Submit” at the end, but only after pausing for 30 seconds so I could manually review the page and handle any unexpected fields or CAPTCHAs.
This was terrifying at first. I watched the first few runs like a hawk, ready to yank the ethernet cable if it went rogue. The script once filled a “Street Address” field with the city name because the label was ambiguous. Another time, it pasted my cover letter into a text box meant for a reference name. I learned to add more specific field detection and built a “dry run” mode that highlighted what it would fill without actually submitting anything.
After a week of refinement, the script could complete about 70% of applications without manual intervention beyond the CAPTCHA and a final glance. That still meant I was saving over an hour per day, and I was applying to twice as many jobs.
The Cover Letter Factory
I hate writing cover letters. I know they matter. I know a good one can set you apart. But after writing my fortieth variation of “I am excited to apply for the role of X because I deeply admire your company’s mission in the Y space,” I felt my soul drying up.
I wrote a script that took a spreadsheet of company names, job titles, and a few bullet points about what interested me, then generated a personalized cover letter using a template. The template was a plain text file with placeholders like {company} and {specific_reason}. I would fill a row in the spreadsheet with the company name, the role, and one genuine sentence about why I liked them. The script stitched everything together into a coherent letter that I could tweak before attaching.
The key was that I never let the script invent anything. I always wrote the reason sentence myself. The automation just handled the repetitive framing. That distinction kept the letters honest and personal, even if the opening and closing lines were formulaic. It also forced me to actually think about why I wanted each job, which turned out to be a useful filter. If I couldn’t write a single genuine sentence about a company, maybe I didn’t really want to work there.
Tracking Everything in a Spreadsheet
Early on, I had a terrible habit of forgetting which companies I had applied to, when I applied, and whether I had followed up. I missed a recruiter email for a week because it went to spam and I had no record of the application. That stung.
I built a simple tracker. A Python script read a CSV file where I logged every application: date, company, role, source, and status. Status was one of “applied,” “rejected,” “interview,” “offer,” or “ghosted.” Each morning, a small script checked for rows where the status was “applied” and the date was more than seven days old, then reminded me to follow up. It also calculated a running conversion rate: what percentage of applications turned into interviews, which sources generated the most responses, and so on.
The data was sobering. After 200 applications over three months, my interview rate was 4%. Referrals had a 30% interview rate. LinkedIn Easy Apply was close to zero. The numbers forced me to stop spraying applications everywhere and focus on networking and direct referrals. Without the tracker, I would have kept applying into the void, fooled by the illusion of activity.
The Results and the Interview That Changed Everything
Over four months, my scripts helped me send 340 applications. That number sounds absurd, but remember: only a fraction were fully automated. The rest were semi automated, with me reviewing each one before submission. I tracked 14 first round interviews, 5 second rounds, and eventually 2 offers. One came from a cold application. The other came from a former colleague who saw a LinkedIn post I wrote about my automation project, thought it was clever, and referred me to her team.
That referral led to the job I accepted. And here is the irony: the scripts themselves had almost nothing to do with getting hired. My new manager told me later that she was impressed by the problem solving mindset the automation demonstrated, but she hired me because of the blog post I wrote about it, not because my application had been perfectly formatted by a bot. The automation didn’t land me the job; the story about the automation did.
The scripts did, however, keep me sane during a demoralizing process. They turned a repetitive grind into a side project that felt productive and occasionally fun. They gave me agency when I felt powerless. And they generated a constant stream of activity that, even with low conversion, kept opportunities flowing until the right one clicked.
The Ethical Line I Almost Crossed
There was a moment when I considered running the application script in a continuous loop, targeting every new listing across multiple boards every hour. It would have been easy to remove the pauses, rotate proxies, and submit hundreds of applications a day. I even sketched out the architecture late one night.
I am glad I didn’t. Not just because it would have gotten my IP banned, but because it would have been wrong. Automated mass applications are spam. They waste recruiters’ time, clog pipelines, and make the whole system worse for everyone. I set a hard limit: I would only automate the parts that were mechanical drudgery, not the human judgment. I would always review each application before it went out. I would never apply to a job I wouldn’t genuinely consider accepting.
That limit kept me on the right side of a very blurry line. I think every developer who automates parts of their life needs to ask where their own line is. My answer was simple: if I wouldn’t do it manually, I wouldn’t automate it. The scripts were a time saving layer on top of decisions I was already making, not a replacement for those decisions.
What I’d Do Differently
Looking back, my automation project was a success in ways I didn’t expect. But there are a few things I would change if I did it again.
I would invest more time in networking and less in scraping. The data was clear: referrals crushed cold applications. I should have spent more of that Python energy on finding warm connections instead of optimizing form fills. A script can’t replicate a genuine conversation.
I would build better error handling from the start. My early scripts crashed silently when a site changed its layout. I lost a few promising leads because I didn’t notice an application never submitted. A simple log file and a daily summary email would have caught those errors immediately.
I would treat the project as a portfolio piece from day one. I didn’t write about my automation until a friend nudged me. That blog post ended up being the single most valuable output of the entire exercise. If I had documented my process publicly from the start, I might have attracted opportunities even sooner.
Final Thoughts
Automating my job search didn’t hand me a dream job on a silver platter. What it did was remove the soul crushing repetition that makes job hunting so draining. It freed up mental energy to focus on the human parts: the networking, the thoughtful applications, the interview prep. And it gave me a story that resonated with the right people.
If you are a developer in the middle of a job search, I am not telling you to build a bot army. I am telling you that the skills you already have can turn a demoralizing process into something you control. Write a small script. Save an hour a day. Use that hour to talk to a real person. That is where the results come from, and no amount of Python can replace that.
