JohnTheKnocker

Applying to crypto and Web3 roles burns the same hour over and over: scroll the listings page, screen out the wrong ones, rewrite the same cover letter with a new company name, fight a screening form, repeat. JohnTheKnocker does that hour for you — but only on doors the candidate actually wants open, with timing and language that don't look like a bot.

The problem it solves

A serious candidate hunting crypto and Web3 roles spends 30-60 minutes per quality application: read the JD, tailor a cover letter, fill the form, answer two or three screening questions, attach the CV, hit submit. Across the 8-15 quality openings posted each week on the half-dozen boards that matter, that's 4-15 hours of evenings every week. Most of it is mechanical — cover letters that are 80% the same paragraph with the company name swapped, screening answers re-keyed for the fifth time this month, the same form shape in slightly different fields.

The existing auto-apply tools solve the wrong problem. They optimize for volume — spray 200 applications a day at the LinkedIn / Indeed firehose and recruiters silently drop them in the same bucket as outsourced agency spam. They charge $30-80 per month for the privilege ($360-960 per year), store the candidate's CV on someone else's server, and have no real coverage of the boards that actually post crypto-native roles. CryptoJobsList, BlockchainHeadhunter, Web3.career — none of them are first-class targets in the mainstream SaaS auto-appliers. That's the gap.

Who needs this most

• Senior engineers and product operators applying to crypto-native roles — 5-15 years in, evaluating 8-15 openings a week on CryptoJobsList and BlockchainHeadhunter, currently losing every Sunday evening to mechanical form-fill while the postings get older.
• Career-transitioners moving into Web3 from FinTech or trading floors — running 30-50 high-effort applications over 4-6 weeks while still working their current role, who do not have evenings to spend re-typing the same cover letter.
• Hiring-stage founders interviewing for executive seats who want every application to be tailored and credible, but cannot justify the 4-6 hours a week the diligence takes when they are also running a company.

The moment this hurts: any Sunday evening between 19:00 and 23:00, when the candidate is staring down the next four hours of cover-letter-and-form labor and quietly considering whether to skip half the postings rather than do them badly.

The solution — in plain terms

JohnTheKnocker watches the job boards a candidate cares about, filters the postings against their rule set (must be remote, must mention Solidity, must not be a contracting agency), writes a tailored cover letter for each match using their CV and their preferred AI provider, and then submits the application on their behalf — typing the way a person types, pausing the way a person pauses, taking screenshots of every submission for the audit trail. The candidate keeps deciding which doors to knock; John does the knocking.

Day-to-day, John runs as a small Docker stack on the candidate's own laptop — no SaaS account, no remote storage of CV or AI keys, no usage cap. Each "Knocker Profile" bundles a target board, a CV, a filter rule set, an AI provider chain, and an optional scheduled watch ("scan every 30 minutes"). The candidate can run any profile in dry-run mode first — John scrapes, filters, generates the cover letters, and queues the applications in a review tab, but stops before clicking submit. Once the candidate trusts a profile, they flip it to auto and let the schedule loop.

It replaces the SaaS auto-apply subscription, the manual cover-letter-rewrite ritual, and the parallel spreadsheet a careful candidate keeps to track applications. Everything lives in one local control panel — the Knock Queue (jobs waiting on a knock), the Run Chamber (live execution feed over WebSockets), and the History (every application with screenshot, full cover letter, AI cost per call, exact submit timestamp, and outcome).

Value delivered — what you get

• Reclaims 4-15 hours a week of mechanical application labor — the cover-letter-rewrite-and-form-fill loop is now an overnight task instead of a Sunday-evening one.
• Keeps the candidate's CV and AI keys on their own machine — no SaaS account holds the CV; AI keys live in the local Postgres, Fernet-encrypted at rest with a key auto-generated to ./data/.jtk_secret on first run, never logged.
• Replaces $360-960 per year of auto-apply SaaS — bring-your-own-key across five AI providers (Anthropic, OpenAI, Grok, Mistral, Ollama) means the only marginal cost is the actual LLM tokens, capped at a configurable daily ceiling.
• Filters by rule, tailors by AI — the two stay separate — the apply/skip decision is deterministic and explainable (a recruiter asking "why did you apply?" gets a coherent answer); AI is only used for the cover letter and screening answers, not for the eligibility call.
• Catches the boards SaaS auto-appliers ignore — CryptoJobsList and BlockchainHeadhunter ship with first-party adapters; the framework is built so adapter #3 is a contained 1-2 day operation, not a refactor.
• Surrenders honestly to CAPTCHAs instead of getting the candidate's IP banned — when Cloudflare Turnstile shows up, John screenshots and stops; the candidate clears it once via a session-bootstrap helper and cookies persist for hours.
• Every door knocked has an audit trail — screenshot, full cover letter, screening answers, AI cost per call, exact submit timestamp — defensible if a recruiter ever asks "did you really submit this?"

Where it delivers outsized value

• Crypto-native and Web3-focused job hunts — the boards that actually post Solidity, DeFi, and protocol-engineer roles (CryptoJobsList, BlockchainHeadhunter) are not first-class targets in mainstream SaaS auto-appliers. This is the gap John fills natively.
• Privacy-first candidates moving in or out of regulated industries — FinTech, MilTech, and GovTech career-transitioners who already will not put a CV on a third-party SaaS. Self-hosting on a laptop is the only acceptable shape; everything in JTK is built to that constraint.
• BYOK operators who already pay for Claude, OpenAI, or Grok subscriptions — they have the keys, they have the quota, they want one tool that uses what they already pay for instead of buying a second AI subscription wrapped in a thin auto-apply UI.

Distinctive features — why this over the alternatives

• Per-site adapters, not a universal apply function — every job board is a snowflake. Each adapter is a Python module declaring its own scraping strategy, applier flow, selectors, and timing profile, so a DOM change on one site never breaks the others and adapter #3 is a contained workstream.
• Humanizer at the base layer — lognormal-distributed jitter between actions, Bezier-curve mouse paths instead of straight-line clicks, variable typing speed by CPM range, random idle pauses, scroll-to-load with stability detection. Adapters inherit the behavior; tuning happens in exactly one place.
• CAPTCHA surrender by design — when Cloudflare Turnstile or hCaptcha is detected, the application is screenshotted and marked captcha_blocked rather than routed through a paid solver. Cleaner ethically; harder to fingerprint as a bot ring; the candidate clears the challenge once via a session-bootstrap tool and reuses the cookies.
• BYOK across five AI providers with fallback chains — LiteLLM is the abstraction; the candidate configures a per-task provider chain (Anthropic primary, OpenAI fallback, Mistral secondary) and a daily cost ceiling, and the platform handles routing, retries, and cost accounting.
• The Vector entity bundles a search direction, not a profile — one CV + filter set + role label + tone + salary band defines a "vector" (DeFi Senior Engineer, remote, $180-220k); multiple vectors run against multiple targets without duplicating the underlying CV/filter pairs.
• Editable prompts with version tracking — every cover-letter prompt, every screening-Q prompt, every field-inference prompt is editable from the UI with Jinja2 validation. Each save bumps a version (user.1, user.2) and is recorded in the AI log, so an A/B comparison between prompt versions is a SQL query away.

Under the hood — built to last

Python 3.12 and FastAPI for the API and worker fleet, PostgreSQL 16 for state, Redis 7 for Celery brokering and WebSocket pub/sub fan-out, Playwright with stealth wiring for the actual browser work, LiteLLM as the AI abstraction, and a React 18 + Vite control panel. The entire stack lives in a single Docker Compose file on the candidate's laptop — no cloud account, no managed service, no per-seat license. Workers use connection pooling with NullPool on the Celery loop boundary so async/sync handoffs do not leak state. CV files live on a mounted volume; AI keys live in Postgres, Fernet-encrypted at rest. Built on foundations that will still run in five years, and built to outlive any single SaaS vendor.

Current maturity

v1.0.0 shipped on 2026-04-30 with two adapters, the full 7-service Docker Compose stack, a 12-table Postgres schema (vectors and AI-key encryption added in migration 0003), roughly 37 REST endpoints, the WebSocket event hub with Redis pub/sub fan-out, the React control panel with nine pages, and 28 unit tests green. Live-verified end-to-end through apply-mode detection against CryptoJobsList (25 jobs scraped in one pass) and BlockchainHeadhunter (20 jobs scraped). The internal-form prefill demo on a real apply page is the one piece not yet recorded — unblocked, waiting on the next listing snapshot. The codebase is approximately 13,000 lines of Python and TypeScript across five application services, built on a 14-document design-spec foundation. Last activity 2026-05-01. Phase 1 is shipped; Phases 2-5 are scoped in the roadmap.

Roadmap — what's next

Phase 2 (3-5 weeks out) adds the trust-and-reliability layer: a live noVNC browser stream so the candidate can watch John knock in real time, application video recordings for replaying weird failures, residential proxy support for boards that fingerprint aggressively, and 3-5 more adapters (Web3.career, RemoteOK with a crypto filter, CryptoCurrencyJobs). Phase 3 is the closed-loop differentiator — an Inbox Watcher that reads Gmail and IMAP, classifies replies as acknowledgment / rejection / interview / offer, and pipes the data into a conversion-analytics dashboard that no spray-and-pray auto-applier can match. Phase 4 fuses with a companion CV Builder (per-job tailored CV variants generated on the fly) and a Job Listing Platform (a first-party adapter with structured data, zero scraping overhead). Phase 5 is the multi-user SaaS form — auth, tiers, hosted browser pool, and an adapter marketplace where community-contributed sites are reviewed and signed before listing.

Working with the architect

JohnTheKnocker is available as a commission-grade custom build when a candidate or career-services org wants the methodology re-applied to a specific board mix or vertical; as an extension partnership when an existing recruitment-tech team wants the adapter framework and humanizer plugged into their stack; or as a strategic advisory engagement when a team building their own auto-apply tooling wants methodology review on the surrender-by-design CAPTCHA stance, the BYOK architecture, and the per-site adapter contracts. Reach out via sintegrium.io or LinkedIn for a 30-minute scoping call.

---

Built by Yurii Staryk · Solution Ecosystem Architect