myjobb
Auto Apply24 Oct 202618 min read

How to Build a Job Application Automation in 2026: Architecture, ATS APIs and Code - and When to Buy Instead

The eight-stage architecture, public ATS job APIs, Playwright form-filling, a screening-question confidence gate and estimated costs for building your own job application bot, and when to buy instead.

shreyansh
Co-Founder / CTO
I want to build a job application automation: a pipeline.py code card that discovers, matches, tailors and submits jobs

Disclosure: myjobb.ai publishes this guide and includes its own product. We describe every tool from its own website and documentation (checked October 2026) and say where myjobb is not the best fit.

Quick answer: If you're thinking "I want to build a job application automation", build an eight-stage pipeline: read jobs from public ATS APIs (Greenhouse, Lever, Ashby), dedupe, score against your resume, tailor a resume per JD, fill forms with Playwright where you're authorised, gate screening answers by confidence, confirm submission, and track. Submitting through ATS APIs needs the employer's key.

Key takeaways

  • Greenhouse, Lever, Ashby, Workable and SmartRecruiters all expose public, unauthenticated job-listing endpoints. Reading jobs is the easy part.
  • Submitting through an API is employer-only. Greenhouse's application POST needs the employer's Base64-encoded API key over HTTP Basic auth. Lever's apply endpoint needs ?key= and returns HTTP 429 above 2 POSTs a second. A candidate-side bot fills the hosted form instead.
  • Indian portals (Naukri, Foundit, Instahyre, Hirist, IIM Jobs) have no public job-seeker API that we could find documented, and logins often need an OTP. Naukri caps applications at up to 50 a day, per its FAQ as cited by Arya by Mentoria. LinkedIn's User Agreement prohibits automation.
  • Under the stated assumptions in our cost table, LLM spend is roughly ₹2 per application. Your build and maintenance hours cost far more.
  • Hard rules: respect ToS, robots.txt and rate limits. Never bypass CAPTCHAs or disguise your bot.

Not building this for the engineering fun of it? myjobb.ai already runs these stages on Indian portals and company career sites. Your first 20 applications are free, with no card and no auto-renewal.

What does it take to build a job application automation?

A job application automation is a pipeline that finds relevant openings, prepares a tailored application for each one, fills and submits the employer's form, answers screening questions, and records the outcome, with a human brought in whenever the system isn't sure. To build a job application automation you need four capabilities: data access (job feeds), language work (matching, tailoring, answers), browser work (forms) and state (what was sent, where, and with which resume).

Most tutorials cover one of the four. Browserbase's job-application template fills forms against a demo board. n8n tutorials on YouTube chain scraping, GPT scoring and resume writing, with little on screening questions, terms of service or confirming submission. Official ATS docs explain endpoints but not the pipeline. This guide covers all four, from the team behind a production agent for Indian job seekers. New to the terms? Start with what an ATS job board is.

I want to build a job application automation: what's the architecture?

The architecture is a linear pipeline with a human-in-the-loop exit at every risky stage: discovery, dedupe, match, tailor, form-fill, screening, submit, track. Each stage writes its result to a store, so a crash or pause doesn't resend an application.

[1 discovery]  public ATS job APIs (Greenhouse, Lever, Ashby, Workable, SmartRecruiters)      ↓[2 dedupe]     hash(company + title + location) → skip anything already seen      ↓[3 match]      score job vs resume + preferences → keep above threshold      ↓[4 tailor]     LLM rewrites resume for this JD (no new facts) → PDF/DOCX      ↓[5 form-fill]  Playwright fills the hosted form you're allowed to automate      ↓[6 screening]  rules → past answers → LLM with confidence gate → else ASK HUMAN      ↓[7 submit]     submit, then confirm via the confirmation page/email, not the click      ↓[8 track]      SQLite/Postgres row per application: status, resume used, follow-up date
  • 1. Discovery. What it does: Pull open jobs · Build it with: requests/httpx against public ATS endpoints · The hard part: Knowing each company's board slug
  • 2. Dedupe. What it does: Drop repeats across boards and days · Build it with: Normalised hash key in your database · The hard part: Same role, different titles or locations
  • 3. Match. What it does: Score fit · Build it with: Embeddings or an LLM rubric · The hard part: Seniority and location rules beat keyword overlap
  • 4. Tailor. What it does: Resume per JD · Build it with: LLM + a template rendered to PDF/DOCX · The hard part: Stopping the model inventing metrics
  • 5. Form-fill. What it does: Fill the employer's form · Build it with: Playwright · The hard part: Every ATS form differs; Workday is multi-step
  • 6. Screening. What it does: Answer knockout questions · Build it with: Rules + memory + LLM gate · The hard part: A wrong "yes" disqualifies you
  • 7. Submit. What it does: Send and confirm · Build it with: Playwright + confirmation check · The hard part: Silent failures look like success
  • 8. Track. What it does: Status and follow-ups · Build it with: SQLite, Postgres or a sheet · The hard part: Matching later emails to applications

Which ATS job-board APIs are public? Greenhouse, Lever, Ashby, Workable, SmartRecruiters

All five expose public, unauthenticated GET endpoints for published jobs. None offers candidates a public way to submit applications by API: the submit endpoints that exist need the employer's credentials. Here's the reference table, checked October 2026.

  • Greenhouse. Read jobs (public): GET https://boards-api.greenhouse.io/v1/boards/{board_token}/jobs?content=true; one job with /jobs/{id}?questions=true · Auth to read: None · Pagination: None (all jobs) · Submit by API?: POST /v1/boards/{board_token}/jobs/{id} · Auth to submit: Employer's Job Board API key, HTTP Basic, Base64 · Gotchas: content is double-encoded HTML; Greenhouse doesn't validate required fields on POST
  • Lever. Read jobs (public): GET https://api.lever.co/v0/postings/{site}?mode=json (EU: api.eu.lever.co) · Auth to read: None · Pagination: skip, limit · Submit by API?: POST /v0/postings/{site}/{posting_id}?key=… · Auth to submit: Employer API key (generated by a Super Admin) · Gotchas: 429 above 2 application POSTs/second; API doesn't support custom questions
  • Ashby. Read jobs (public): GET https://api.ashbyhq.com/posting-api/job-board/{org}?includeCompensation=true · Auth to read: None · Pagination: None · Submit by API?: Not in the public posting API · Auth to submit: Employer API key · Gotchas: Skip jobs where isListed is false; structured salary data
  • Workable. Read jobs (public): GET https://apply.workable.com/api/v1/widget/accounts/{subdomain}?details=true · Auth to read: None · Pagination: None · Submit by API?: Not in the public widget endpoint · Auth to submit: Employer or partner credentials · Gotchas: telecommuting: true marks remote; HTML descriptions
  • SmartRecruiters. Read jobs (public): GET https://api.smartrecruiters.com/v1/companies/{company}/postings?limit=100&offset=N · Auth to read: None · Pagination: offset/limit (max 100) · Submit by API?: Not in the public postings endpoint · Auth to submit: Employer or partner credentials · Gotchas: Descriptions only in /postings/{id}; company IDs are case-sensitive
  • Workday. Read jobs (public): Career site's own search call: POST https://{tenant}.wd{N}.myworkdayjobs.com/wday/cxs/{tenant}/{site}/jobs · Auth to read: None · Pagination: limit max 20 · Submit by API?: No public apply API · Auth to submit: Candidate account per tenant, multi-step form · Gotchas: total is reliable only on page 1; undocumented, so check the site's terms

Two employer-side APIs often turn up in "build an auto-apply bot" answers, and neither helps a job seeker. Greenhouse's Harvest API (POST /v3/applications) creates an application for an existing candidate using the hiring company's credentials. Lever's main API (hire.lever.co) authenticates with the customer's key or OAuth, at a default 10 requests a second. Both are built for employers and their integration partners.

To find which ATS a company uses, look at the careers link: boards.greenhouse.io or job-boards.greenhouse.io, jobs.lever.co, jobs.ashbyhq.com, apply.workable.com, jobs.smartrecruiters.com or myworkdayjobs.com. The path segment after the host is usually the slug you need. For per-ATS form anatomy, see our guide to Workday, Greenhouse, Lever and Ashby application forms.

Rather skip the build? myjobb applies on Greenhouse, Ashby and Workday career sites and on Naukri, Foundit, Instahyre, Hirist and IIM Jobs, and builds a resume tailored to any job you pick. Start free: your first 20 applications are on us. No card, no auto-renewal.

How to evaluate building vs buying

Judge a DIY build and any managed tool on the same six criteria: coverage (which ATSs and Indian portals), answer quality on screening questions, submission confirmation, ToS compliance, total cost (cash plus your hours), and maintenance burden when forms change.

Method: endpoint and auth details come from Greenhouse's Job Board API docs, Lever's Postings API README and developer docs, Ashby's developer hub and a community reference of public ATS endpoints (Mersetti), all checked October 2026. Tool facts come from each vendor's own pages or the roundup named beside the price. The costs below are estimates from stated assumptions, not production measurements.

Step 1: Discover and dedupe jobs from public APIs

Read each company's public board on a schedule, cache the response, normalise it to one schema, and hash company, title and location to drop duplicates. One request per board every few hours is plenty, since jobs don't change by the minute.

"""discover.py: read public ATS job boards politely and normalise them (illustrative)"""import hashlib, html, json, pathlib, re, timeimport requestsS = requests.Session()S.headers["User-Agent"] = "personal-job-scout/0.1 (contact: you@example.com)"  # say who you areCACHE = pathlib.Path(".cache"); CACHE.mkdir(exist_ok=True)BOARDS = {    "greenhouse": "https://boards-api.greenhouse.io/v1/boards/{slug}/jobs?content=true",    "lever": "https://api.lever.co/v0/postings/{slug}?mode=json",    "ashby": "https://api.ashbyhq.com/posting-api/job-board/{slug}?includeCompensation=true",}def fetch(ats: str, slug: str, max_age_s: int = 6 * 3600):    f = CACHE / f"{ats}-{slug}.json"    if f.exists() and time.time() - f.stat().st_mtime < max_age_s:        return json.loads(f.read_text())                 # fresh cache: no request at all    r = S.get(BOARDS[ats].format(slug=slug), timeout=20)    if r.status_code == 429:                             # server asked us to slow down        wait = r.headers.get("Retry-After", "120")        time.sleep(int(wait) if wait.isdigit() else 120)        r = S.get(BOARDS[ats].format(slug=slug), timeout=20)    r.raise_for_status()    data = r.json()    f.write_text(json.dumps(data))    time.sleep(1.0)                                      # stay at or below ~1 request/second    return datadef normalise(ats: str, slug: str, data):    if ats == "greenhouse":        for j in data["jobs"]:            yield dict(company=slug, title=j["title"], url=j["absolute_url"],                       location=(j.get("location") or {}).get("name", ""),                       jd=html.unescape(j.get("content", "")))   # content is double-encoded    elif ats == "lever":        for j in data:            yield dict(company=slug, title=j["text"], url=j["hostedUrl"],                       location=j.get("categories", {}).get("location", ""),                       jd=j.get("descriptionPlain", ""))    elif ats == "ashby":        for j in data["jobs"]:            if j.get("isListed", True):                yield dict(company=slug, title=j["title"], url=j["jobUrl"],                           location=j.get("location", ""), jd=j.get("descriptionPlain", ""))def job_key(job) -> str:    norm = lambda s: re.sub(r"[^a-z0-9]+", " ", (s or "").lower()).strip()    return hashlib.sha1(f"{norm(job['company'])}|{norm(job['title'])}|{norm(job['location'])}".encode()).hexdigest()

Store job_key as the primary key in your tracking table (Step 5), and skip any job whose key already exists. Strip tags from jd before sending it to an LLM, because tokens cost money.

Step 2: Match and tailor with an LLM

Score each job before you spend anything on tailoring it. Then tailor only the jobs above your threshold, under a strict no-invention rule.

  • Match: hard filters first (location, seniority band, visa or relocation), then an LLM or embedding score of the JD against your resume. Log the reasons (skill overlap, years, location) so you can audit bad matches.
  • Tailor: give the model your master resume as the only source of facts. Have it rewrite your summary and the most relevant bullets in the JD's vocabulary and return a list of must-haves it couldn't cover. Reject any output that contains an employer, date or number missing from the master resume. A simple diff against your master's entities catches most problems.
  • Render to a single-column PDF or DOCX. Greenhouse's Job Board API accepts PDF, DOC, DOCX, TXT and RTF, and Lever's docs say image files won't be parsed.

Step 3: Fill the form with Playwright (only where you're authorised)

Use Playwright to open the employer's hosted application form, fill fields by their visible labels, upload the tailored resume, and stop for review. Only automate forms you have permission to use. Greenhouse explicitly recommends its own embedded application form, so treat the hosted form as the supported route.

"""fill_form.py: fill a form you are authorised to automate, then pause for review (illustrative)"""from playwright.sync_api import sync_playwrightPROFILE = {"First Name": "Asha", "Last Name": "Rao", "Email": "asha@example.com", "Phone": "+91 90000 00000"}def fill_application(url: str, resume_pdf: str, answers: dict, submit: bool = False) -> str:    with sync_playwright() as p:        browser = p.chromium.launch(headless=False)      # a normal, visible browser: no disguises        page = browser.new_page()        page.goto(url, wait_until="domcontentloaded")        for label, value in {**PROFILE, **answers}.items():  # answers already passed the gate            field = page.get_by_label(label, exact=False)            if field.count() == 0:                return "needs_human"                      # unknown form shape: hand it over            field.first.fill(value)        page.locator("input[type=file]").first.set_input_files(resume_pdf)        if page.locator("iframe[src*='captcha'], [id*='captcha'], [class*='captcha']").count():            return "needs_human"                          # a CAPTCHA means stop, not solve        page.screenshot(path="before_submit.png", full_page=True)        if not submit:            input("Dry run: review the browser, then press Enter to close.")            return "dry_run"        page.get_by_role("button", name="Submit").click()        page.wait_for_load_state("networkidle")        confirmed = page.get_by_text("thank you", exact=False).count() > 0        return "submitted" if confirmed else "unconfirmed"

Run with submit=False until you trust it on a given ATS. Dropdowns need select_option() and radio buttons need check(). Workday's multi-step flow (account, autofill, several screens) needs one handler per step.

Bot to fill job applications and screening questions: how should it answer?

A bot that fills job applications and screening questions should answer in this order: deterministic rules from your profile, then answers you've given before, then an LLM, but only above a confidence threshold. Anything else goes back to you. Screening questions decide knockouts, so a confident wrong answer is worse than a pause.

Indian forms add their own fields: current and expected CTC (usually in LPA), notice period in days, current city, relocation, years of experience per skill, and sometimes "immediate joiner?". Map these with rules, not with the LLM.

Screening-question prompt (use only after rules and memory miss):

SYSTEM: You answer job-application screening questions for ONE candidate.Use ONLY the FACTS and PAST ANSWERS below. Never invent experience, salary, dates or eligibility.Return JSON only: {"answer": string, "source": "facts" | "past_answer", "confidence": 0.0-1.0, "needs_human": boolean}Rules:- If OPTIONS are given, "answer" must be one option, copied exactly.- Salary: use the LPA figures in FACTS exactly. Notice period: use FACTS' days.- Eligibility (work authorisation, relocation, shifts, degree): answer only if FACTS state it;  otherwise needs_human = true.- "Years of experience with X": use FACTS' per-skill years; if X is missing, needs_human = true.- If you are unsure for any reason, set needs_human = true and confidence below 0.5.FACTS: {facts_json}PAST ANSWERS: {similar_past_answers_json}QUESTION: {question}OPTIONS: {options_or_null}

The confidence gate:

import json, re"""PROMPT = the screening prompt above as a template (escape its literal JSON braces as {{ }} for str.format).memory = a dict-like store of accepted answers with a .similar(question) lookup."""RULES = [  # deterministic first: these never go to the LLM    (re.compile(r"notice period", re.I),          lambda f: f"{f['notice_days']} days"),    (re.compile(r"current (ctc|salary)", re.I),   lambda f: f"{f['current_ctc_lpa']} LPA"),    (re.compile(r"expected (ctc|salary)", re.I),  lambda f: f"{f['expected_ctc_lpa']} LPA"),]def answer(question, options, facts, memory, llm, threshold=0.85):    for rx, fn in RULES:        if rx.search(question):            return fn(facts), "facts"    past = memory.get(question.strip().lower())    if past and (not options or past in options):        return past, "past_answer"    out = json.loads(llm(PROMPT.format(facts_json=json.dumps(facts), question=question,                                       similar_past_answers_json=json.dumps(memory.similar(question)),                                       options_or_null=json.dumps(options))))    if out["needs_human"] or out["confidence"] < threshold or (options and out["answer"] not in options):        return None, "ask_human"                      # pause this application and notify the candidate    memory[question.strip().lower()] = out["answer"]  # remember only answers the gate accepted    return out["answer"], out["source"]

When the result is ask_human, park the application, send yourself the question (email, Telegram, WhatsApp, whatever you check), and resume when you reply. A good bot asks more often in week one and less as its memory grows.

Step 5: Submit, confirm and track

Count an application as submitted only once you see a confirmation page or email, never because the click happened. Then write one row per application, so dedupe, follow-ups and reporting all work off the same store.

CREATE TABLE applications (  job_key      TEXT PRIMARY KEY,            -- hash from Step 1  company      TEXT, title TEXT, url TEXT, ats TEXT,  match_score  REAL, resume_file TEXT,      -- which tailored resume was sent  status       TEXT CHECK (status IN ('queued','dry_run','needs_human','submitted','unconfirmed','interview','rejected')),  submitted_at TEXT, follow_up_on TEXT, notes TEXT);

Retry unconfirmed rows by hand, not automatically, because a blind retry can create a duplicate application. Lever, for example, merges candidates by email, so duplicates are visible to the recruiter.

LinkedIn, Naukri and Indian portals: APIs, OTPs, ToS and rate limits

We found no public job-seeker API documented for Indian job portals, logins often need an OTP, and each portal sets its own daily limits and terms. Any automation there has to work inside your own logged-in session, at human pace, and stop for OTPs. LinkedIn is off-limits for automation altogether.

  • LinkedIn. Public job-seeker API: None for applying · Login: Account · Limits and terms to respect: LinkedIn's User Agreement prohibits automating the site, so don't automate Easy Apply. Apply to LinkedIn-found roles on the employer's own career page
  • Naukri. Public job-seeker API: None documented · Login: Account, often with OTP · Limits and terms to respect: Daily limit of up to 50 applications (Naukri FAQ, as cited by Arya by Mentoria). Read Naukri's terms before automating your account
  • Foundit, Instahyre, Hirist, IIM Jobs. Public job-seeker API: None documented · Login: Account, OTP on new devices · Limits and terms to respect: Check each portal's terms. Pace well below any stated limit
  • Greenhouse, Lever, Ashby, Workable, SmartRecruiters. Public job-seeker API: Read-only job APIs (above) · Login: None to read · Limits and terms to respect: Lever: 429 above 2 application POSTs/second. Cache and identify your client
  • Workday. Public job-seeker API: None published · Login: Account per company · Limits and terms to respect: Multi-step forms. Treat the search call as undocumented and go slowly

The non-negotiables for any job application bot:

  1. Read the terms first. If a site's terms prohibit automated access or applying, don't automate it.
  2. Respect robots.txt for every page you fetch. It's the Robots Exclusion Protocol (RFC 9309), and it tells crawlers what they may request.
  3. Respect rate limits: about one request a second per host at most, caching, honouring Retry-After on 429s, and a User-Agent that identifies you.
  4. Never bypass protections. No CAPTCHA solving, no stealth plugins, no fingerprint spoofing, and no rotating proxies to dodge blocks. A CAPTCHA or block means stop and hand over to a human.
  5. Pause for OTPs and never store them.
  6. Only automate your own accounts and forms you're authorised to use.

How much does it cost to build a job application automation? (estimates)

Under the assumptions below, LLM tokens cost about ₹2.2 per application and a hosted browser adds under ₹0.5. The big costs are the hours you spend building and maintaining it. These are estimates, not measurements. Swap in your own model prices and rates.

Assumptions (illustrative): 16,500 input and 2,200 output tokens per application (matching 3,000/200; tailoring 6,000/1,500; five screening questions at 1,500/100 each). LLM at US$1 per million input tokens and US$4 per million output. A hosted browser at US$0.10 per browser-hour for 3 minutes per application. A US$5/month VPS. ₹88 per US$. 40 hours to build v1 and 4 hours a month to maintain, valued at ₹1,000/hour.

  • LLM tokens. Per application: $0.0253 ≈ ₹2.23 · Per month at 350 applications: ≈ ₹779 · Notes: (16,500 × $1 + 2,200 × $4) ÷ 1,000,000. Varies 10x+ by model
  • Browser minutes. Per application: $0.005 ≈ ₹0.44 · Per month at 350 applications: ≈ ₹154 · Notes: ₹0 cash if you run Playwright on your own laptop
  • Proxies. Per application: ₹0 · Per month at 350 applications: ₹0 · Notes: Not needed for a personal project. Proxies used to dodge limits count as evasion
  • Hosting and database. Per application: — · Per month at 350 applications: ≈ ₹440 · Notes: VPS plus SQLite
  • Cash subtotal. Per application: — · Per month at 350 applications: ≈ ₹1,373 · Notes: Before your time
  • Build time (one-off). Per application: — · Per month at 350 applications: ≈ ₹40,000 · Notes: 40 h × ₹1,000
  • Maintenance time. Per application: — · Per month at 350 applications: ≈ ₹4,000 · Notes: 4 h/month as forms change
  • Managed agent: myjobb Pro. Per application: ≈ ₹2.85 · Per month at 350 applications: ₹999 · Notes: 350 applications, GST included, no auto-renewal. Includes Indian portals, the resume builder, referral finder and cold email
  • Managed agent: myjobb Max. Per application: ≈ ₹2.00 · Per month at 350 applications: ₹1,999 · Notes: 1,000 applications a month
  • Upfront. DIY build: Your build hours · Managed agent (myjobb): ₹0. First 20 applications free · Autofill extension (Simplify Copilot): Free
  • Monthly. DIY build: ≈ ₹1,373 cash + maintenance (estimate) · Managed agent (myjobb): ₹999 (Pro) or ₹1,999 (Max) · Autofill extension (Simplify Copilot): Free; Simplify+ $39.99/month (as listed by Jobscan, July 2026)
  • Indian portals. DIY build: Your own sessions, within each portal's terms · Managed agent (myjobb): Naukri, Foundit, Instahyre, Hirist, IIM Jobs · Autofill extension (Simplify Copilot): Not listed
  • Career-site ATS. DIY build: Forms you write handlers for · Managed agent (myjobb): Greenhouse, Ashby, Workday (not Lever) · Autofill extension (Simplify Copilot): Workday, Greenhouse, Lever, iCIMS, Taleo, SmartRecruiters (autofill)
  • Who clicks submit. DIY build: Your code · Managed agent (myjobb): The agent, after confirmation checks · Autofill extension (Simplify Copilot): You
  • Best for. DIY build: Learning, or a niche set of companies · Managed agent (myjobb): Indian job seekers who want it run end to end · Autofill extension (Simplify Copilot): Hands-on applicants on global ATS forms

Verdict: build it if the engineering is the point, or if you target a few dozen companies on Greenhouse, Lever and Ashby. Buy if you need Indian portals, Workday at volume, or your evenings back.

What's the best auto apply tool for software engineers?

The best auto-apply tool for software engineers depends on where you're applying. Software roles at product companies often sit on Greenhouse, Lever, Ashby or Workday career sites, and Indian tech roles also run through Instahyre and Hirist. Choose a tool that covers your targets and asks before it guesses on "years of experience with Go" or notice-period questions.

  • myjobb.ai. Greenhouse / Lever / Ashby: Greenhouse, Ashby (not Lever) · Workday: Yes · Indian tech boards: Instahyre, Hirist, Naukri, Foundit, IIM Jobs · Who submits: The agent · Price (as listed, Oct 2026): 20 free, then ₹999/month · Best for: Software engineers in India
  • Simplify Copilot. Greenhouse / Lever / Ashby: Greenhouse, Lever (autofill) · Workday: Autofill · Indian tech boards: No · Who submits: You · Price (as listed, Oct 2026): Free; Simplify+ $39.99/month* · Best for: US-style ATS forms with you in control
  • JobCopilot. Greenhouse / Lever / Ashby: Company career pages · Workday: Not stated · Indian tech boards: No · Who submits: The tool · Price (as listed, Oct 2026): $0.93–$1.05/day · Best for: Global career-page roles
  • LazyApply. Greenhouse / Lever / Ashby: Greenhouse named, plus LinkedIn, Indeed · Workday: Not stated · Indian tech boards: No · Who submits: The tool · Price (as listed, Oct 2026): $99–$999/year · Best for: US and Canada only, by its own description
  • Your own build. Greenhouse / Lever / Ashby: Read APIs + form handlers · Workday: Hard · Indian tech boards: Your sessions, within terms · Who submits: Your code · Price (as listed, Oct 2026): Estimated above · Best for: Engineers who want full control

*As listed in Jobscan's AI resume builder roundup (updated July 2026).

How myjobb.ai runs this pipeline in production

myjobb.ai is an AI job agent for job seekers in India. It finds jobs that match your resume, applies for you on Indian job portals and company career sites, builds a resume tailored to any job description you pick, finds people who can refer you, emails recruiters and hiring managers from your own inbox, and follows up. With WhatsApp connected you get a message for each application sent, and every step is in an activity log.

Here's how its stages map to the architecture above:

  • Discovery and match: it scans jobs from Indian portals and company career sites and scores each one against your resume and preferences, showing a match % with reasons such as skill overlap, seniority and location.
  • Tailor: auto-apply sends your default resume; for any job you pick, the resume builder creates an ATS-friendly resume tailored to its description.
  • Form-fill and submit: it applies through your own logged-in session on Naukri, Foundit, Instahyre, Hirist and IIM Jobs, and directly on Greenhouse, Ashby and Workday career pages (not Lever, which puts a captcha on every submit). You connect portals once with a Chrome extension. Sessions are encrypted (AES-256-GCM) and revocable at any time. It doesn't automate LinkedIn Easy Apply. For roles you find on LinkedIn, it applies on the employer's career page when the role is listed there.
  • Screening: it answers from your profile first, then from your previous answers, and uses AI only above a confidence threshold. When unsure, it asks you on WhatsApp or by email. It pauses for OTPs.
  • Pacing: random 2–6 second pauses between steps, a 20-minute back-off when a site pushes back, and each portal's daily limits respected.
  • Track: an application counts as "submitted" only once the portal confirms it. Every step goes into an activity log, and with WhatsApp connected you get a message for each application sent. On Pro and Max, the referral finder returns the top 10 people likely to refer you, and outreach goes from your own Gmail or Outlook, up to 50 emails per mailbox per day by default.

1M+ job seekers have used myjobb, and it has processed 400K+ applications. It can't guarantee interviews, and some assessments still need you.

Start free: your first 20 applications are on us. No card, no auto-renewal.

Risks, limits and how to stay safe

The main risks of a DIY bot are account restrictions, wrong answers and silent failures. Each has a fix.

  • Account restrictions: automating a site against its terms can get your account limited. Stay off LinkedIn automation, keep Naukri well under its daily limit, and pace every action.
  • Wrong answers: a confident wrong knockout answer costs you the role. Use rules first, a confidence gate, and ask-human as the default.
  • Silent failures: a click isn't a submission. Confirm and record it.
  • Privacy: encrypt stored sessions and resumes, never log OTPs, and keep API keys out of your repo.
  • Spam: volume without matching wastes recruiters' time and your reputation. Raise your match threshold before you raise volume.

FAQ

I want to build a job application automation. Where do I start?

Start with read-only discovery. Pull jobs from the public Greenhouse, Lever and Ashby endpoints for 10–20 target companies, store them with a dedupe hash, and score them against your resume. Add LLM tailoring next, then Playwright form-filling in dry-run mode. Turn on submission last, one ATS at a time, once confirmations are reliable.

Can I submit applications through the Greenhouse or Lever API?

Not as a job seeker. Greenhouse's Job Board API accepts application POSTs only with the employer's Base64-encoded API key, and Lever's apply endpoint needs the employer's key parameter and rate-limits above 2 POSTs a second. Both are meant for a company's own careers site. Candidates apply through the hosted form instead.

For your own applications, the main constraint is usually each site's terms of service, though computer-access and data-protection laws can apply too. Use public APIs as intended, respect robots.txt and rate limits, automate only your own accounts, and skip any site whose terms prohibit automation, LinkedIn included. Never bypass CAPTCHAs or other security measures. If in doubt, ask a lawyer.

Can a bot fill job applications and screening questions accurately?

Yes, if it answers in a strict order: rules from your profile for CTC, notice period and location, then your past answers, then an LLM, used only above a confidence threshold and only with a valid option. Anything else should pause and ask you. Bots that let the LLM guess eligibility questions are the ones that disqualify you.

Does Naukri have a public API for job seekers?

Not one we could find documented for searching or applying as a candidate, and the same goes for Foundit, Instahyre, Hirist and IIM Jobs. Automation there has to run inside your own logged-in session, pause for OTPs, stay within the portal's daily limit (Naukri's is up to 50 applications, per its FAQ as cited by Arya by Mentoria) and follow its terms.

Can I automate LinkedIn Easy Apply?

You shouldn't. LinkedIn's User Agreement prohibits automating the site, and accounts can be restricted. A safer route is to use LinkedIn for discovery only, then apply on the employer's own career page, which is often Greenhouse, Lever, Ashby or Workday. myjobb takes that route for LinkedIn-found roles on Greenhouse, Ashby and Workday.

Should I use Playwright, Selenium or an AI browser agent?

Use Playwright for known forms. It's fast, scriptable and lets you fill by label and confirm submission. AI browser agents such as Stagehand-based templates adapt to new layouts but cost more per run and are harder to audit. Selenium works too, with more boilerplate. Many builders combine Playwright handlers for common ATSs with an agent fallback that only drafts and never submits.

How do I handle CAPTCHAs and OTPs in a job application bot?

Don't try to defeat them. A CAPTCHA means the site doesn't want automated traffic at that point, so stop and hand the application to a human. An OTP belongs to the account owner, so pause, notify the person, and resume only after they enter it. Never use solving services, stealth plugins or fingerprint spoofing.

What is the best auto apply tool for software engineers?

For software engineers in India, myjobb.ai covers Greenhouse, Ashby and Workday career sites plus Instahyre, Hirist and Naukri, with 20 free applications to start. If you're applying to US roles and want to stay hands-on, Simplify Copilot's free autofill works on many ATS forms, including Workday, Greenhouse and Lever. LazyApply describes itself as limited to the US and Canada.

Bottom line: build a job application automation, or buy one

To build a job application automation that actually works, read jobs from public ATS APIs, dedupe and match, tailor with a no-invention rule, fill forms with Playwright where you're authorised, gate screening answers by confidence, and count only confirmed submissions. Respect terms, robots.txt and rate limits throughout, and never bypass protections. If you'd rather spend your evenings interviewing than maintaining form handlers, use an agent.

Next step: start free with myjobb.ai. Your first 20 applications are free, with no card and no auto-renewal. It applies on Naukri, Foundit, Instahyre, Hirist, IIM Jobs and company career sites, builds a tailored resume for any job you pick, and messages you on WhatsApp for each application sent.

Sources

Changelog: 24 October 2026, first published. Endpoints, auth rules and tool prices checked October 2026. Cost figures are labelled estimates.

Two hands reaching for each other over a meadow: a job seeker and the myjobb AI job agent working together

no more solo job hunting.

Apply to your first job