The CAPTCHA is one of the most widely recognised pieces of internet infrastructure in the world. Every internet user has encountered one: the distorted letters, the grid of blurry images, the checkbox that watches your mouse movements to decide if you are human. And every internet user outside of a narrow Western, high-bandwidth, able-bodied demographic has been failed by one.
Courage Garikai has written something rare: a security book that is also a development economics book, a human factors book, and an implementation manual. He argues, persuasively and with data from real production systems in Zimbabwe, that CAPTCHAs do not work for the markets where internet growth is fastest — and that the alternative is not some exotic AI-powered system, but a simple, decades-old cryptographic primitive (proof of work) combined with basic server-side signals that anyone can implement.
This is an important book for two reasons. First, it offers a concrete, tested, low-cost alternative to a broken status quo, complete with code, weights, and deployment checklists. Second, it insists — correctly — that software built for emerging markets must be tested on emerging- market devices, by emerging-market developers, for emerging-market users. The $22 phone test is not an appendix; it is the core argument.
If you build forms, operate a website, or make procurement decisions about security software, read this book. Then remove your CAPTCHA.
— Tawanda Chikore, Harare, November 2026
This is a book about bot mitigation written from Harare. The central claim is simple: the CAPTCHA — the distorted text, the traffic-light puzzle, the “I am not a robot” checkbox — is broken. It does not stop bots. It stops people. It stops them because they cannot see the puzzle, because they do not have the device to render it, because they do not have the bandwidth to load it, because they do not know what a fire hydrant is, because they cannot move a mouse precisely, or because they cannot afford the data to download 300 KB of Google surveillance scripts before filling out a form.
The book is built around three propositions:
Bot mitigation is an economic problem, not an artificial- intelligence problem. The goal is to make abuse more expensive than it is worth to the attacker. You do not need to tell humans and bots apart; you need to make automated abuse cost more than the revenue it generates.
The correct bot mitigation for low-resource markets — and for ordinary users everywhere — is invisible proof: a small computational challenge that runs in the background, server-side signals that detect automation without demanding anything from the user, and friction only when signals are ambiguous. No puzzles. No third- party tracking. No image grids.
Part I makes the argument. If you do nothing else, read Chapters 1–5. They will change how you see every CAPTCHA-protected form you encounter online.
Part II quantifies the threat. If you are not convinced that bot mitigation needs fixing, the numbers here are drawn from production logs and industry reports.
Part III is the architecture. Six chapters describe the invisible proof stack — proof of work, velocity, reputation, behavioural signals, fingerprinting, friction — with concrete implementations, parameters, and code sketches.
Part IV is the production section, including the Proofhand case study (our implementation running at scale across seven products), measurement methodology, and calibration guidance.
Part V covers privacy, the CAPTCHA-solving labour market, AI-native bots, and the case for open proof as infrastructure.
A Tools Index at the back contains the PoW reference implementation in JavaScript and Python, the trust-score schema, and deployment checklists.
This is not a machine learning book. The techniques described require no ML models, no AI, no neural networks, and no training data. They use SHA-256, timing heuristics, IP reputation lists, and simple arithmetic. ML-based bot detection exists; it is expensive to operate, difficult to audit, and unnecessary for the 98% of cases where simple economics-based defences suffice.
This is not a book about stopping sophisticated targeted attacks (Archetype 4 from Chapter 10). Dedicated adversaries targeting your site specifically require dedicated security operations. This book is about the 99% of automated abuse that hits every public form within hours of launch, which can be stopped with a small amount of well- placed code.
This is not a book arguing that all third-party bot detection services are evil. Cloudflare, Arkose, and other vendors offer sophisticated products that are appropriate for high- value targets (financial services, government, large enterprise). This book argues that for the vast majority of websites and small businesses, those tools are overkill, privacy-invasive, and inaccessible to a large share of users — and a simpler, cheaper, more open alternative exists.
All production data in this book is drawn from ColdCode Si Labs server logs between January 2026 and November 2026, across seven products serving approximately 4,000 paying customers and hundreds of thousands of monthly visitors in Zimbabwe, South Africa, Kenya, Nigeria, and Zambia. Device and network data is measured from actual traffic; anecdotes about specific customers are used with permission or anonymised. Industry statistics are cited in the Notes section.
Courage Garikai
ColdCode Si Labs · Harare
DCAI · 2026
For the shopkeeper in Chitungwiza who lost forty registrations to a bot flood in one weekend because her $15 phone could not render a puzzle.
For the grandmother in Mbare who was locked out of her own grant application because the CAPTCHA timed out before she could read it.
And for the builders who keep shipping puzzle gates to markets where the devices, the data plans, the literacy levels, and the fingers do not match the assumptions.
It was a Saturday morning in October 2025 when Rumbidzai called me. She runs a small poultry supply business in Chitungwiza, selling day-old chicks and feed to smallholder farmers around Harare. She had launched a WhatsApp-based registration form for a farmer-training workshop — free, two hundred places, first come first served. To prevent bots from grabbing all the slots, she had added a CAPTCHA to the registration page, the kind with “select all images containing traffic lights.” She set it up using a popular CAPTCHA service and did not think much about it.
By 10 a.m. she had twenty registrations. She expected hundreds. She tested the form on her own phone and it worked. She shared it with five friends; two of them said it loaded, three said they could not get past the puzzle. One said the puzzle images never loaded at all. One said he clicked six times and kept getting new puzzles before he gave up. One said his screen was too small to see which square the traffic light was in.
Rumbidzai is not a technologist. She sells chicks. She had done what every WordPress tutorial and every Stack Overflow answer told her to do: add a CAPTCHA to stop bots. The CAPTCHA stopped bots. It also stopped approximately 90% of the humans she was trying to reach.
By the time she called me at noon, she had thirty-one registrations against 200 slots — and server logs showed 648 page loads, of which 298 reached the CAPTCHA, and 38 completed it. An 87% failure rate on the CAPTCHA step, on traffic she knew was human.
We removed the CAPTCHA and replaced it with a different check. In the next two hours she received 214 additional registrations, all from real farmers using real phone numbers. We detected three bot submissions (three forms submitted in under 900 milliseconds from the same IP block). We blocked those silently. The workshop was full by 4 p.m.
That afternoon, I read the logs from the failed CAPTCHA attempts. I looked at device types, connection speeds, time- to-complete, and the browsers of visitors who failed. The pattern was clear: the CAPTCHA was filtering out the very users Rumbidzai’s business served. It was filtering out users with $15 Huawei Y5 phones on Econet 3G. It was filtering out users on Opera Mini (which does not render the puzzle widget at all). It was filtering out users who took more than thirty seconds to solve a puzzle because the images loaded slowly over a 2G connection and timed out. It was filtering out users with low vision who could not make out the traffic lights on a 4.5-inch screen. It was filtering out users who did not know what a traffic light looks like because they live in a rural community where there are none.
The bots, of course, sailed through. The three bot submissions we detected after the CAPTCHA came off were not the first bots of the day — they were the first bots we caught because they were sloppy. A determined bot using a CAPTCHA-solving service (which costs approximately $1.50 per 1,000 solves) can pass any puzzle-based CAPTCHA in seconds. The CAPTCHA did not stop them. It only inconvenienced them by $0.0015 per attempt — a cost they are happy to pay.
I left Rumbidzai’s workshop that Saturday knowing what the next product had to be. Bot mitigation is necessary. But the current tooling — image puzzles, audio challenges, checkbox click-detection — is built for the American iPhone- on-fiber user, and it does not merely fail in African markets; it actively filters out the humans while letting the bots through. What is needed is a bot mitigation approach that works for users on $15 phones with 2G connections, that is privacy-preserving, that does not require Google scripts, that costs almost nothing to run, and that works regardless of whether the user knows what a traffic light is.
That product became Proofhand. This book explains how it works, why it works, and how to build something similar yourself. The central argument is simple: the correct bot mitigation for low-resource markets is invisible proof of work combined with server-side behavioural signals, not puzzles. And this approach is not a compromise — it is better than CAPTCHA at every level, including security, accessibility, privacy, and cost. It is not “CAPTCHA but for Africa.” It is the design that should have been shipped everywhere in the first place.
Let me be precise about what I mean when I call CAPTCHA colonial infrastructure. I do not mean the term metaphorically, and I do not use it as a generic pejorative. I mean it as a technical description of a system built in one context, exported globally without adaptation, and whose burdens fall disproportionately on people the system was never designed to accommodate.
CAPTCHA — Completely Automated Public Turing test to tell Computers and Humans Apart — was invented at Carnegie Mellon University in 2000 by Luis von Ahn, Manuel Blum, Nicholas Hopper, and John Langford. The original CAPTCHA presented distorted letters that a human could read and a computer could not. It assumed:
A device with a large, high-resolution screen capable of rendering distorted text legibly.
A keyboard for typing the answer.
A reliable, fast internet connection capable of loading the challenge quickly enough to complete before a timeout.
Literacy in the Latin alphabet (and English, for early implementations).
Visual acuity sufficient to read distorted text — which means no significant visual impairment.
One of the most persistent myths about CAPTCHA is that it tests for humanness. It does not. It tests for a specific set of capabilities and circumstances that are correlated with humanness in the context where CAPTCHA was developed. The two are not the same.
Let me list what modern CAPTCHA actually measures: It measures the quality of your device. A puzzle with 4×4 image grids requires a screen large enough to render sixteen distinct images and a processor fast enough to load them within the timeout period. A phone with a 480×854 display, a 1.3 GHz quad-core processor, and 1 GB of RAM — the technical specifications of a $15 smartphone sold in Zimbabwe in 2026 — will load a reCAPTCHA challenge slowly, will render images at low resolution, and will frequently fail the implicit behavioural timing analysis (because the page itself loads slowly, mouse/pointer events fire with lag, and the system interprets this lag as “non- human”).
It measures the speed and cost of your connection. A user on fiber will load CAPTCHA resources in under 500 milliseconds. A user on 2G will take 8–15 seconds to load the same resources, during which time the challenge may time out or new puzzles may be generated. The user on 2G appears “slow” to the behavioural detector, and slow behaviour is flagged as bot-like.
It measures your familiarity with American visual culture. Select all images with traffic lights. Select all images with crosswalks. Select all images with bicycles parked on a sidewalk. A user who lives in a village without traffic lights cannot answer these questions reliably. This is not a cognitive deficit. It is a cultural mismatch. The puzzle does not test whether you are human; it tests whether you are the kind of human the puzzle designers had in mind.
It measures your visual and motor ability. Clicking a 40×40 pixel square on a touchscreen requires precise finger control and good vision. Users with tremors, low vision, or motor impairments fail at higher rates. The Americans with Disabilities Act (ADA) has been used to sue over inaccessible CAPTCHAs in the United States; in countries without equivalent disability protection, there is no legal recourse.
It measures your willingness to be tracked. Modern reCAPTCHA v3 does not present a visible puzzle at all — it runs a behavioural script in the background that tracks mouse movement, scrolling, typing cadence, browser fingerprint, IP history, and cookie state, and assigns a “humanness score.” This is not a challenge you pass or fail; it is a surveillance apparatus that decides whether you are permitted to submit a form. Users who block third-party cookies, use privacy browsers, or share a network with hundreds of other users (as is common on African mobile networks) are scored lower, regardless of their actual humanity.
What CAPTCHA does not measure is what it claims to measure: whether the entity on the other end is a human being. A bot operated by a competent attacker can pass any CAPTCHA currently deployed, because there is a multi- million-dollar industry — CAPTCHA-solving farms, automated solvers using fine-tuned vision models, and residential proxy networks — that exists specifically to defeat these challenges at costs between $0.50 and $3 per thousand solves. The bot that solves CAPTCHAs does not have a $15 phone. It has a datacenter GPU, a residential proxy IP, and a fine-tuned vision model trained specifically on reCAPTCHA images.
The uncomfortable truth is that CAPTCHA does not reliably stop bots. It reliably stops specific kinds of humans. The defenders have misidentified the threat, and the humans paying the cost are exactly the humans the internet least needs to exclude.
There is a specific number I want you to hold in your head:
18 seconds . That is the median time it takes a grandmother in my family, age 72, reading glasses on, doing me a favour by testing a form on a tablet I gave her, to complete a standard reCAPTCHA image puzzle when the images load properly and she knows what the objects are. On a slow connection with images she does not recognise, it takes her between 40 seconds and two minutes. She is not unintelligent. She is not unfamiliar with technology (she sends WhatsApp voice notes and reads the news on that tablet every morning). She is just a normal human being of a certain age, with normal human eyesight and normal human reflexes, taking a normal amount of time to do a visual puzzle on a screen.
The median time for a bot using a commercial CAPTCHA- solving service to complete the same puzzle: less than 2
seconds . The median time for a bot using a self-hosted vision model fine-tuned on CAPTCHA datasets:
under 700
milliseconds . The fastest recorded human CAPTCHA solver in published research — a competitive puzzle-solver in India who does it for a living — takes about 4 seconds. Bots solve CAPTCHAs faster than the fastest humans because the fastest humans are still using their eyes and fingers, and bots are using a GPU.
This is the central paradox of CAPTCHA-based bot mitigation in 2026. The puzzles that defeat grandmothers, farmers, low-literacy users, and users on cheap phones are trivial for a properly equipped bot. They are trivial because the economic incentive to solve them is large enough to fund an entire industry devoted to doing so, and because the AI capability required to solve image classification puzzles has been commoditised. A vision model that can pass reCAPTCHA with 99% accuracy can be fine-tuned for a few hundred dollars on consumer hardware.
Why, then, do CAPTCHAs still exist? Because they are good enough for the lazy bots — the badly written scripts that hammer forms without solving any challenge at all. And because there is no default alternative shipped in frameworks. Developers add CAPTCHA because everyone else does, because it is a checkbox on the security checklist, because it feels like doing something, and because for a Silicon Valley developer testing on a MacBook Pro over gigabit Wi-Fi, the CAPTCHA seems to work fine. They do not see the users it filters out, because those users never complete registration and never become customers, and the developer never wonders where they went.
The lazy bot problem is real. You do need to block the flood of badly written scripts that will hit any public form within minutes of it being indexed. But CAPTCHA is a 500- kilogram sledgehammer designed for a nail that requires a 10-gram flyswatter. The lazy bots can be stopped with lightweight controls that are invisible to humans. The sophisticated bots will solve CAPTCHA faster than you can blink. The puzzle gate stops neither category effectively; it only stops ordinary humans in non-standard contexts.
Every CAPTCHA provider claims their system is accessible. reCAPTCHA offers an audio challenge as an alternative to image puzzles. hCaptcha offers the same. The marketing copy on every CAPTCHA landing page includes the phrase “WCAG compliant” or “accessible to screen reader users.”
These claims are false in practice, and particularly false outside the environments where accessibility testing is done.
The audio challenge presents distorted speech over background noise and asks the user to type what they hear.
For users with hearing impairments, this is obviously inaccessible. For users on cheap phone speakers in noisy markets (a minibus taxi rank, an informal market stall, a busy street), the audio is unintelligible. For users who do not speak English as a first language — which is the majority of people on earth — the distorted English digits are nearly impossible to parse. For users on 2G connections, the audio file downloads slowly and times out. Even for a user with perfect hearing, quiet surroundings, and native English, audio CAPTCHA solve rates are approximately 50% lower than visual CAPTCHA solve rates, according to independent studies by accessibility researchers.
The “invisible” CAPTCHA (v3) that claims to require no user interaction is even worse for accessibility-adjacent users. It scores users in the background based on behaviour. Users who do not use a mouse (keyboard-only navigation, switch devices, voice control) exhibit behaviour that looks “bot- like” to the classifier because they do not move a mouse in the expected ways. Users on slow connections have timing profiles that look non-human. Users who block tracking scripts break the behavioural analysis entirely and are forced into the challenge loop.
The deeper problem is that all CAPTCHA systems treat accessibility as an alternative — an audio option that you can switch to if you cannot do the visual challenge. But accessibility is not an alternative path. If your security gate requires an average human to possess a specific set of capabilities (fast device, fast internet, American visual literacy, Latin-script literacy, fine motor control, good vision, good hearing), and provides a “separate but equal” alternative for everyone else, your system is not accessible.
It is discriminatory, with a side channel for a narrow subset of the excluded users.
The only truly accessible bot check is an invisible one. If the check runs in the background, uses ordinary browser capabilities, does not require the user to see or solve anything, and reaches a decision based on signals that a normal human interaction produces regardless of ability or device, then accessibility is not an add-on feature. It is the default state. That is what Part III of this book describes.
There is a test I use for every security control. It is simple: can my grandmother complete it?
My grandmother is seventy-eight. She uses a Nokia feature phone with a 2.4-inch screen and physical buttons. She receives money on EcoCash. She calls her children on WhatsApp voice notes. She can read Shona fluently and English at a primary-school level. She cannot use a touchscreen keyboard quickly. She cannot solve a grid of blurry traffic lights. She cannot read distorted text. She cannot identify bicycles in images — she knows what a bicycle is, but the blurry, low-contrast, cropped photographs that CAPTCHA systems show are not bicycles as she recognises them.
If your security control blocks my grandmother from accessing a service she needs — her pension, her clinic appointment, her grandson’s school fees payment — your security control is broken. Not “suboptimal,” not “needs improvement,” not “a reasonable trade-off.” Broken. A system that blocks a real person with real needs in order to stop hypothetical bots has failed at its job, because the purpose of security is to enable legitimate access, not to prevent all access.
This test is not sentimental. It is operational. My grandmother is not an edge case. There are millions of people like her. In Zimbabwe alone there are 2.3 million people over 60, most of whom use feature phones or basic smartphones. There are users with visual impairments, users with motor impairments, users with cognitive disabilities, users in low-literacy communities, users with $15 phones — all of them real, all of them potential customers, citizens, and participants in the digital economy.
If your bot mitigation cannot pass the grandmother test, it is not fit for purpose in this market.
Before we design a defence, we need to understand the threat. Bot traffic is not monolithic. There is no such thing as “a bot” — there is an ecosystem of automated traffic with different motivations, different budgets, different technical capabilities, and different economic models. Defending against all of them with one tool is like defending a house against mosquitoes, burglars, and thunderstorms with a single lock.
Let me give you the numbers. They are drawn from Cloudflare’s 2026 Bot Report, from Arkose Labs’ State of Fraud report, from our own traffic logs at ColdCode Si Labs across seven products serving primarily African traffic, and from several private conversations with operators who deal with bot traffic at scale.
Global automated traffic share: Approximately 49% of all web traffic in 2026 is automated. Of that, roughly 28% is “good” bots — search crawlers, uptime monitors, RSS readers, legitimate API clients, webhook delivery systems.
The remaining 21% is malicious: credential stuffing, web scraping, account creation fraud, form spam, card testing, click fraud, and vulnerability scanning. Africa has a slightly higher share of malicious automated traffic (24–27%) because the widespread use of carrier-grade NAT (thousands of users sharing a small pool of IP addresses) makes IP-based blocking less effective.
Credential stuffing volume: Approximately 12 billion credential-stuffing attempts are made globally per day in 2026, according to security researcher Troy Hunt’s aggregation of breach data. These attempts use username/ password pairs from previous data breaches (there are over 8.4 billion unique pairs in public circulation) to test logins on other services. The success rate per attempt is low — typically 0.2–2% — but at 12 billion attempts per day even a 0.2% success rate produces 24 million account takeovers per day.
Form spam and account creation: Every public web form will begin receiving spam submissions within hours of being indexed. A new unprotected signup form with no bot mitigation typically receives 50–500 spam signups per day within a week of launch, depending on how valuable the account is perceived to be (free trials, discount codes, and anything involving crypto get hit hardest; contact forms get hit lightest).
Card testing: Approximately $20 billion worth of card testing (submitting small authorisations with stolen card numbers to check which are still valid) occurs every year, mostly against merchant payment forms. Card testers typically test 100–1,000 cards per session against a single form.
CAPTCHA-solving economy: The commercial CAPTCHA- solving industry does approximately $300 million per year in revenue, according to market research from GoDaddy and Dark Reading. Rates range from $0.50 per thousand for fully automated AI solving to $3 per thousand for human- solver services that route CAPTCHAs to workers in low- wage countries. The existence of a $300 million industry whose sole purpose is to defeat your bot gate should tell you everything you need to know about how well CAPTCHA works against a motivated adversary.
Attack costs: An attacker running a credential stuffing or form spam campaign can generate approximately 10,000 requests per hour from a residential proxy network at a cost of $2–$5 per thousand requests (including proxy rental and CAPTCHA solving). Against a form with no bot mitigation, this is enough to create 5,000–10,000 spam accounts per day for $25–$50. Against a form with strong invisible bot mitigation, the same volume costs the attacker $50–$200 per day and drops below break-even for most forms of spam (where the monetisation per spam account is typically $0.01–$0.10).
These numbers matter because they define the economic threshold for defence. Bot mitigation does not need to be unbreakable. It needs to be expensive enough that attacking you costs more than the attack is worth. A defence that raises the cost of abuse from $2 per thousand to $20 per thousand will eliminate 90% of automated abuse against ordinary forms, because most spam campaigns are low- budget operations that move on when they find an easier target.
This is the economic model that invisible proof is designed around. We are not trying to build Fort Knox. We are trying to make spamming our form cost more than it earns.
Credential stuffing is the single most common form of bot attack against login forms. The mechanics are simple: an attacker obtains a list of email/password pairs from a previous data breach (there are billions in circulation on hacking forums and dark web markets), writes a script that submits those pairs to your login endpoint one by one, and records the ones that succeed.
Because approximately 60% of people reuse passwords across multiple sites (Verizon DBIR 2026), a meaningful percentage of these attempts will log in successfully.
There are 8.4 billion unique email/password pairs in publicly accessible breach collections as of 2026, according to Hunt’s Have I Been Pwned database. That is more than one breached credential for every human being on earth with an email account. Your users are almost certainly in one of these collections. If you run a login form, credential stuffing is not a theoretical threat; it is a thing that is happening to your form right now, every day, whether you see it or not.
What does credential stuffing look like in server logs? It looks like: - POST requests to the login endpoint at high volume from a large number of IP addresses. - Requests with valid email addresses (real users, drawn from breach data) and incorrect passwords. - Requests distributed across IP addresses in residential proxy networks to avoid IP-based rate limits. - Requests with valid User-Agent strings (because the attacker copies real browser headers).
- Requests with no session cookies, no prior visit to the login page (the attacker POSTs directly to the endpoint without first GETting the form). - High failure rates (98%+) from attacking IPs.
Credential stuffing is where invisible proof starts to earn its keep. A legitimate user visits your site, loads the login page, types their email and password over several seconds, and submits. A credential stuffing bot sends POST requests directly to the login endpoint from a script without loading the page, with no proof token, with perfectly uniform timing, with no cookies, with form completion times under 100 milliseconds. These two profiles are not difficult to tell apart. You do not need a puzzle to tell them apart. You need to require that a token be issued when the form loads and presented when the form is submitted, and you need to check that the request has characteristics consistent with a real browser session.
Beyond credential stuffing, there are three other categories of automated traffic that most public-facing sites encounter.
Content scraping. Automated scripts that download your entire site or your product catalogue for competitive reasons (price scraping, content theft, clone sites). Scrapers range from polite crawlers that respect robots.txt (search engines) to aggressive scrapers using headless Chrome on residential proxies that can download your entire catalogue in an hour. Scrapers typically do not create accounts or submit forms; they just read pages. Invisible proof can detect and slow them (by issuing a computational challenge to requests that exhibit scraping-like patterns) but the more effective defence against determined scrapers is legal, rate limiting, and business model adaptation (competitors who scrape your prices can only do so if you display your prices publicly, which most merchants must).
Form spam. Automated submissions to contact forms, comment forms, signup forms, and lead-generation forms.
The purpose is usually either advertising (posting links to counterfeit goods, adult sites, crypto scams) or lead generation (affiliate marketers submitting fake leads to collect CPA bounties). Form spam is the most visible form of bot abuse because the spam ends up in your inbox or database. It is also the easiest to stop, because form spam bots are usually the laziest class of attacker — they use simple HTTP POST scripts that do not execute JavaScript, do not load form pages, and do not present any kind of proof token. A simple proof-of-work check blocks 99% of form spam.
Synthetic account creation. Automated creation of accounts for use in other attacks: fake social media accounts, accounts for abusing free trials, accounts for voucher/promo abuse, accounts for ad fraud, accounts for astroturfing. This is the category that motivated much of the original CAPTCHA development in the early 2000s (free email account creation by spammers). Synthetic accounts are economically valuable (a verified Gmail account sells for $0.50–$2 on dark web markets), so attackers are willing to invest more in defeating bot checks — including solving CAPTCHAs via commercial services. Stopping synthetic accounts requires a layered approach because the attacker is willing to spend real money to create each account.
Each of these categories has a different break-even cost, which means the defences can be calibrated accordingly.
Form spam needs to cost the spammer more than a fraction of a cent per submission. Synthetic accounts need to cost the attacker more than the $0.50–$2 that the account is worth. Credential stuffing needs to cost enough that testing a thousand passwords is more expensive than the few successful logins are worth to the attacker.
Card testing is a specialised form of automated attack that targets payment forms specifically. The attacker possesses a list of stolen credit card numbers (typically purchased on dark web markets for $5–$15 per card) and wants to determine which of those cards are still valid and can be charged. They do this by submitting authorisation requests against merchant payment forms: usually a small charge ($0.01–$1.00) or even a zero-dollar authorisation, if the payment processor allows it. Cards that succeed are then used for larger purchases or resold at a higher price.
Card testing is particularly damaging for merchants because payment processors charge fees per authorisation (even failed ones), and excessive failed authorisations can lead to the merchant losing their payment processing account entirely. Stripe and other processors monitor chargeback and authorisation-failure rates, and merchants with high rates are flagged as high-risk and sometimes dropped. A card-testing attack that runs 5,000 failed authorisations against your form in an evening can cost you $100–$500 in processing fees and put your merchant account at risk.
Promo fraud exploits coupon codes, free trials, referral bonuses, and new-account promotions. If your business offers a $10 credit for new signups, an attacker will create 1,000 synthetic accounts and collect $10,000 in credits. If you offer refer-a-friend bonuses, the attacker creates chains of referred synthetic accounts to collect the bonuses. If you offer a free trial that requires a card, the attacker uses card- tested numbers to activate free trials at scale.
Both card testing and promo fraud require more than a simple bot check — they require velocity limits (how many cards can be tested from one IP, one device fingerprint, one card bin in a given period), velocity patterns (real humans do not submit 100 cards from one IP in ten minutes), and economic thresholds (flag accounts that spend exactly $0 or that use a new card immediately after signup). The invisible proof layer is the first gate; velocity and reputation controls (Part III, Chapter 13) form the second gate; monetary controls (minimum charge amounts, AVS checks, 3-D Secure) form the third.
For the purposes of designing defences, it is useful to divide bot traffic into four archetypes based on the attacker’s budget and sophistication. Each archetype requires a different set of controls.
Archetype 1: The script kiddie / lazy spammer. Uses a 20-line Python or curl script to POST directly to forms without loading pages, executing JavaScript, or maintaining cookies. This is the vast majority of form spam and simple scraping. These attackers have budgets measured in pennies, use cheap datacenter IPs, and do not solve CAPTCHAs (their scripts cannot even render them). A simple proof-of-work challenge plus requiring a token issued on page load blocks 100% of these attackers. They cannot afford any defence that requires more than trivial effort to bypass.
Archetype 2: The tooled-up amateur. Uses off-the-shelf automation tools (Selenium, Playwright, Puppeteer, commercial bots like Sentry MBA or OpenBullet) with residential proxy networks and basic CAPTCHA-solving integration. These attackers have budgets of $50–$500 per campaign, can render JavaScript, can solve CAPTCHAs at $1–$3 per thousand, and can simulate basic browser behaviour. They are stopped by a combination of proof of work (at sufficient difficulty), behavioural analysis (mouse movement, typing cadence, time on page), and reputation signals. They cannot afford to spend more than a few cents per request, so a defence that raises their cost to $0.05 per request puts them out of business.
Archetype 3: The professional attacker. Operates at scale for profit, using custom automation, residential proxy rotation, fingerprint spoofing, AI CAPTCHA solvers, and sometimes human labour for high-value targets. Typical budget: thousands to tens of thousands of dollars per campaign. They can pass any generic puzzle CAPTCHA, can spoof browser fingerprints, and can tune their timing to evade simple behavioural analysis. They are stopped by layered defences (proof of work + behavioural analysis + reputation + velocity limits + per-account risk scoring + targeted friction for high-risk actions), not by a single check. The economic goal is to make the per-account cost exceed the monetisation value.
Archetype 4: The targeted attacker. A specific adversary targeting your specific site, with custom-built tools and a budget large enough to invest in bypassing your specific defences (state actors, competitors engaging in espionage, large-scale fraud rings). This archetype cannot be stopped with generic bot mitigation; it requires dedicated security monitoring, manual threat intelligence, and incident response. For ordinary small businesses and websites, this archetype is rare. It is not the threat most operators need to worry about, and it is not the threat this book is designed to address.
The critical insight is that Archetype 1 (the script kiddie/ lazy spammer) accounts for roughly 90% of automated traffic hitting ordinary forms, and they can be blocked almost entirely by invisible proof of work alone. Archetype 2 accounts for another 8–9% and is blocked by adding behavioural and reputation signals. Archetype 3 accounts for 1–2% and requires layered controls with targeted friction. Archetype 4 is less than 1% of traffic against ordinary sites.
A CAPTCHA-based defence overspends on Archetype 1 (it uses an expensive puzzle where a simple proof would suffice) and underspends on Archetype 3 (the professional attacker solves CAPTCHAs easily). An invisible proof stack is calibrated to the economic reality of each archetype.
The most important question in bot mitigation, and the question most security vendors will not answer honestly, is: how much does each successful abuse action earn the attacker?
The answer tells you how much your defence must cost the attacker per attempt to make the attack uneconomical.
Attack type
Attacker revenue
per success
Break-even cost per attempt Form spam
(advertising links)
$0.001–$0.01
$0.001
Credential stuffing
(account takeover)
$0.50–$5 per account
(varies by account
value)
$0.002–$0.02 Synthetic account
for promo abuse
$1–$10 (value of
promo)
$0.01–$0.10 Card testing
$5–$15 per valid card
(resale value)
$0.01–$0.05 Scraping product
prices
$0.001–$0.01 per
page
$0.001
Fake reviews/
astroturfing
$0.50–$5 per posted
review
$0.01–$0.10 These numbers are not precise — they vary by market, by attacker, and by the specific service being attacked — but they establish the scale. For the vast majority of attacks against ordinary small business and SaaS forms, the break- even point is under one cent per attempt. An attacker paying more than a penny per attempt is losing money on the average campaign.
This is why proof of work is such an effective primary defence. A proof-of-work challenge that requires 50 milliseconds of CPU time on a modern smartphone costs the attacker approximately $0.0004 per request in cloud compute (or $0.001 per request on residential proxy rental).
That is enough to raise the cost of form spam from $0.50 per thousand to $1–4 per thousand, which puts it above the break-even for Archetype 1. Increasing the difficulty to 200 milliseconds raises the cost to $4–15 per thousand, which covers most of Archetype 2.
Critically, a 50-millisecond proof takes 50 milliseconds on a cheap phone as well as on a flagship phone. It takes 50 milliseconds on 2G as well as on fiber (the proof is computed locally after the page loads, so connection speed does not affect the computation). It takes 50 milliseconds regardless of visual ability, literacy, language, or age. It does not require the user to see, read, solve, or click anything.
The puzzle CAPTCHA asks the user to spend 18 seconds of their time and the cost of loading 300 KB of images to block attackers who spend $1.50 per thousand to solve the puzzle automatically. The proof-of-work challenge asks the attacker’s CPU to spend 50 milliseconds and asks the user for zero seconds. The economic asymmetry is exactly reversed: the human pays nothing, the attacker pays in proportion to the scale of their abuse.
This is why invisible proof is not a compromise or a workaround for low-resource markets. It is the correct architecture for bot mitigation anywhere.
I keep a $22 phone on my desk.
It is an Itel A18, purchased in August 2026 from a phone shop at East Road in downtown Harare. It runs Android 12 Go edition on a 1.3 GHz quad-core Unisoc processor with 1 GB of RAM and a 4,000 mAh battery. The screen is 5 inches at 480×960 resolution. The back has a fingerprint smudge.
The charging port is micro-USB. It came with a free transparent silicone case that is already yellowing.
Before we ship any feature at ColdCode Si Labs, I test it on this phone first. Not in Chrome DevTools with device emulation — on the actual phone, over actual Econet 3G, sitting on my desk in Harare. I load the page. I tap the buttons. I fill the form. I submit it. I time how long it takes. I see what breaks.
The $22 phone reveals bugs that no emulator will: - JavaScript that runs fine on my MacBook causes a 6-second freeze on the Itel’s 1.3 GHz processor. - CSS gradients that render smoothly on high-end phones cause visible banding on the 480p screen. - Third-party scripts (analytics, CAPTCHA, chat widgets) that load asynchronously on fiber block rendering for 30 seconds on congested 3G. - Touch targets that are 44px on my screen are too small to tap accurately on the cheap resistive-feeling capacitive touchscreen. - WebP images served by our CDN did not render on the stock browser (we had to add JPEG fallbacks).
This $22 phone has saved us more customer frustration than every code review, QA sprint, and automated test combined. I recommend that every developer building software for African markets buy one. Do not buy it online and have it shipped to your office in the US or Europe — buy it locally, from a stall in the local market, with the same pre-installed apps, the same network configuration, the same firmware that your customers will have. Put your own SIM card in it. Use it as your primary phone for one week.
You will learn more about how your product actually performs than six months of analytics data will tell you.
Every software team has a testing lab with iPhones and Pixel phones. Almost none has a $22 Itel or a $15 Tecno on their test bench. That is a mistake. The $22 phone is the real QA device. The iPhone is the fantasy.
Proof of work (PoW) is the oldest and most misunderstood concept in cryptography. In the context of bot mitigation it is simple: when a visitor loads a form, your server sends them a small mathematical challenge that requires a modest amount of computation to solve. The visitor’s browser computes the solution in the background (without showing anything to the user) and includes the solution when submitting the form. Your server verifies the solution in microseconds. Legitimate users never notice. Bot operators submitting thousands of forms from scripts must spend compute cycles solving thousands of challenges.
The specific construction used in Proofhand is a Hashcash- style puzzle, adapted for web use. The server generates a random challenge string and specifies a difficulty level (number of leading zero bits required in the SHA-256 hash).
The browser iterates over nonce values until it finds one that, when combined with the challenge, produces a hash with the required number of leading zeros. It sends that nonce back. The server computes one hash to verify.
At difficulty 18 (2^18 = 262,144 expected hash iterations), this takes approximately 50 milliseconds on a modern smartphone browser and 10–20 milliseconds on a laptop browser. At difficulty 20, it takes approximately 200 milliseconds on a phone. At difficulty 22, approximately 800 milliseconds. We use difficulty 18 for standard forms (contact forms, signups) and difficulty 20 for high-value forms (login endpoints, payment forms).
Let me walk you through the economics. A modern CPU can compute approximately 10 million SHA-256 hashes per second. At difficulty 18 (262k hashes per challenge), one core can solve approximately 38 challenges per second. To submit 1,000 form requests, an attacker needs approximately 26 seconds of single-core time on a cloud server. Cloud CPU time costs approximately $0.01–$0.03 per core-hour. That puts the per-thousand cost at roughly $0.0001–$0.0002 of cloud compute if the attacker runs on datacenter hardware. This seems too cheap to matter — until you realise that Archetype 1 attackers do not run JavaScript at all, cannot solve the challenge, and are blocked outright without even needing to compute anything.
The cost only applies to attackers who execute JavaScript, which is Archetype 2 and above.
But cloud servers are not enough because cloud IP addresses are known and easily blocked. Professional attackers use residential proxy networks, where each request comes from a real home ISP connection, and each proxy request costs money. Residential proxies cost approximately $2–$5 per thousand requests regardless of the payload. Adding proof of work does not change proxy cost, but it adds the need to run JavaScript execution (a headless browser) rather than simple HTTP requests. That raises the infrastructure cost from approximately $0.50 per thousand (simple curl requests via proxies) to approximately $2–$5 per thousand (headless Chrome instances via residential proxies). Combined with the CPU time and the need to allocate more concurrent instances, the total cost for an attacker using headless Chrome on residential proxies lands at approximately $5–$15 per thousand requests against a difficulty-20 challenge, compared to $0.50 per thousand against an unprotected form.
That is a 10–30x increase in the attacker’s cost. And the human pays nothing — the challenge is computed while the page loads, before the user even starts typing.
The proof of work challenge has three critical properties that make it preferable to CAPTCHA:
It is device-egalitarian. A 50ms computation on a $15 Android phone takes 50ms. It does not require a large screen, a fast connection, or visual literacy. The computation runs locally. If the phone’s processor is slow, the computation takes proportionally longer — but it is still computed in the background while the user is filling in the form, so it does not delay submission.
Proof of work stops lazy bots and raises costs for tooled amateurs. It does not, by itself, stop professional attackers who are willing to run headless browsers on residential proxies. The second layer of defence is server- side velocity and reputation checking — essentially, your server remembers visitors and their behaviour, and it uses that memory to make trust decisions.
Velocity checks answer simple questions about request patterns: - How many requests has this IP address made in the last hour? - How many accounts have been created from this device fingerprint in the last day? - How many failed payment attempts has this card bin produced? - How quickly did this request arrive after the page was loaded? - How many usernames has this session attempted?
The correct thresholds depend on your application. A public contact form might reasonably accept three submissions per IP per hour. A login form might accept five failed attempts per account before escalating. A payment form might accept three card authorisations per IP per day. Real users almost never hit these thresholds; automated attacks hit them within minutes.
Velocity checks must be applied carefully in markets with carrier-grade NAT, where thousands of users share a small number of IP addresses. If you block by IP address naively, you will block real users. There are three mitigations: 1.
Use device fingerprinting (Chapter 15) in addition to IP address, so you can distinguish between multiple users behind a single IP. 2. Set per-IP limits high enough that a family, an office, or an entire village sharing one IP will not hit the limit accidentally (30 requests per IP per hour is a reasonable starting point for most forms). 3. When a threshold is tripped, do not immediately block; add friction (Chapter 18) — require a higher difficulty proof, or issue a one-time puzzle challenge.
Reputation checks go beyond velocity to track the history of identifiers: - IP reputation: Is this IP from a known proxy/ VPN/datacenter range? Datacenter IPs almost never submit legitimate payment forms from ordinary consumers.
Residential IPs with a history of legitimate traffic have higher trust. - Email domain reputation: Does this email domain have a history of producing spam accounts?
Disposable email domains (there are public lists) can be flagged. - Card bin reputation: Has this card bin been
used for card testing before? - Phone number reputation: Has this phone number been used to create multiple accounts? - Device reputation: Has this device fingerprint been seen submitting spammy forms across other sites?
(This requires either a shared reputation network or enough of your own traffic to build a signal.)
Reputation systems work best when they produce scores rather than binary block/allow decisions. A request from a known datacenter IP with a disposable email address and no proof-of-work solution gets blocked outright. A request from a residential IP with a valid proof solution, normal behavioural timing, and no negative history gets accepted instantly. A request that is borderline — residential IP, valid proof, but an email domain that has produced spam accounts in the past — gets friction: a higher difficulty proof, a delayed response, or a one-time challenge.
Alegitimate human interacting with a web form behaves differently from an automated script, even when the script runs inside a real browser. The difference is visible in timing and interaction patterns. You do not need to track mouse movements across the entire site or build surveillance-grade behavioural profiles to measure it. A handful of signals, measured only during the form interaction itself, are sufficient:
Time from page load to form submission (time-on- page). A legitimate user loads a form, reads the page, fills in fields, and submits. This takes at least several seconds for even the simplest form. A bot that renders the page with a headless browser and submits instantly will have a time-on- page of 200–500 milliseconds, even with the proof of work computed. Reject submissions faster than 1.5 seconds (allowing that fast users on simple forms may submit in 3–5 seconds; setting the floor at 1.5 catches only automation).
Time between keystrokes and field interactions. A human types their name character by character, with intervals between keystrokes ranging from 50–300 milliseconds. A script fills fields programmatically in 0 milliseconds between inputs. Detecting programmatic field filling (all fields populated in a single JavaScript tick, or intervals under 10ms between every field being filled) is a strong bot signal without requiring invasive mouse-tracking.
Form-field interaction order. A human typically fills fields in top-to-bottom order (name, email, phone, message). A bot may fill them in DOM order, which may differ from visual order, or fill them in alphabetical order of field name.
Mouse/touch movement before submission. On pages where the user has a mouse or touchscreen, the existence of any movement events (even a few) before submission is a strong human signal. Bots that do not move the mouse or touch the screen (because they are interacting via JavaScript DOM methods) can be distinguished. This signal is not available to keyboard-only users, which is why it must be a soft signal rather than a hard block.
JavaScript environment checks. Basic legitimate browser properties can be checked without surveillance: does the window have a reasonable screen size? Does it have a functioning history object? Are standard APIs (WebGL, Canvas, AudioContext) present in a configuration that matches a real browser? Sophisticated fingerprinting libraries (like FingerprintJS) are overkill for this purpose and introduce privacy concerns; a handful of sanity checks catches the laziest headless browsers.
The critical design rule for behavioural signals: measure only what you need during the interaction, and discard it after the decision. Do not set third-party cookies. Do not track the user across sites. Do not build persistent user profiles. The signal is computed when the form is submitted, used to make a trust decision, and then discarded except for the internal reputation score attached to the identifier. This is the difference between bot mitigation and surveillance.
Related to behavioural signals but worth its own chapter: the way a human fills a form has a choreography that automation does not reproduce.
This is not about timing alone. It is about the natural pauses, corrections, backtracks, and small frictions that are present in any real human interaction.
A human filling out a registration form: 1. Types their first name. 2. Pauses briefly while they move to the next field. 3.
Types their last name. 4. Tabs or touches the email field. 5.
Types their email address, possibly making a typo and correcting it (backspacing and retyping a character). 6.
Clicks or tabs to the phone field. 7. Fills the phone number, possibly switching between keyboards (numeric to alpha for any suffix). 8. Scrolls down if the form is long. 9. Reads whatever comes next (terms, a question, a dropdown). 10.
Selects a dropdown option (requiring a click, a scroll, a selection). 11. Reviews what they typed, maybe correcting a field. 12. Clicks submit.
This sequence takes 15–60 seconds for a simple form. It involves mouse movements or touches, scroll events, focus changes, backspacing, and hesitation. A bot — even a sophisticated one running in headless Chrome — typically: 1. Sets all field values programmatically via JavaScript in a single tick. 2. Never scrolls, never moves the mouse, never changes focus naturally. 3. Clicks submit within 1–3 seconds of page load. 4. Has no backspaces, no corrections, no pauses.
You do not need fancy machine learning models to distinguish these patterns. Simple heuristics — presence of any keydown events (as opposed to programmatic value setting), presence of any field corrections, presence of scroll events on long forms, presence of mouse or touch movement before submission — will flag the vast majority of automated form fills.
The most important behavioural signal is also the simplest: did the user type anything? A bot using .value = "spam@example.com" to populate a field does not generate keyboard events. A human typing “spam@example.com” generates 18 keydown events. Checking for the presence of keyboard events (with an allowance for paste, which is a legitimate
human
action)
immediately
separates programmatic form fills from human ones. This is not a perfect signal — accessibility tools and password managers populate fields without keyboard events — but it is a strong signal that can be combined with other signals rather than used as a hard block.
For users who do not use a keyboard (switch devices, voice control, password managers, auto-fill), the absence of keyboard events must not be treated as a block. It must move the request into a higher-risk bucket that receives either a friction challenge (Chapter 18) or elevated post- submission monitoring (delaying account activation for a few minutes while other signals are checked). This is the layered approach: no single signal blocks, but signals add up.
Browser fingerprinting — identifying a browser/device combination based on the unique set of properties it exposes — is a powerful technique for bot detection. It is also a privacy minefield when done at cross-site tracking scale (that is how ad networks track users across the web).
Used within a single site, for the narrow purpose of bot detection, and without persisting identifiers across visits beyond what is necessary for fraud prevention, fingerprinting is both legitimate and privacy-respectable.
A minimal honest fingerprint for bot mitigation combines a handful of signals that are naturally exposed by any browser making a request:
HTTP headers: User-Agent, Accept, Accept-Language, Accept-Encoding, Connection (do these match a real browser’s typical header set? Automated scripts often send unusual headers or miss standard ones).
TLS fingerprint: the TLS handshake parameters (cipher suites, extensions) differ between real browsers and simple HTTP clients. This is a strong signal that can detect even well-engineered bots that fake User-Agent headers. Libraries like JA3/JA3S provide standard TLS fingerprinting.
IP address and ASN: is the request coming from a known ISP, a hosting provider, a VPN service, or a Tor exit node?
Screen and viewport characteristics: does the screen size match the User-Agent’s claimed device? A “mobile” User- Agent with a 1920×1080 viewport is suspicious.
Timezone and language: does the browser’s timezone roughly match the IP geolocation? A mismatch is not proof of a bot (people travel, VPNs exist), but it adds a point to the risk score.
The invisible verification layer is where all the signals from Chapters 12–16 converge. It is a piece of middleware that runs on your server before processing any form submission. It computes a trust score from 0 to 100 based on the signals present, and it makes one of three decisions:
Accept (score > 75): Process the submission normally. The user sees nothing.
Friction (score 30–75): Accept the submission but apply mild friction — delay processing by a few seconds, require a slightly higher proof-of-work difficulty on the next request, hold the submission in a queue for manual review if it is high-value (like a payment).
Challenge (score < 30): Reject the submission silently (do not tell the attacker which signal tripped the filter) or, for high-value forms where a false positive would be costly to a real user, issue a one-time visible challenge (Chapter 18).
Here is a simplified version of the scoring used in Proofhand, with weights calibrated against our traffic: Signal
Points Valid proof-of-work solution, difficulty 18
+40 Proof-of-work solution took 20–500ms
(credible browser time)
+10 Time-on-page > 5 seconds
+10 Keypress events detected on at least one field +10 Signal
Points IP from residential ISP (not datacenter/VPN/ Tor)
+10 TLS fingerprint matches known browser
+10 Header set matches claimed User-Agent
+5 Mouse/touch movement detected
+5 No accelerated field fill (inter-keystroke times > 10ms)
+5 No negative reputation on IP/email/device
+5 Max 100 (adjusted) Negative signals
Deduction No proof-of-work solution
−100 (instant reject) Time-on-page < 1 second
−50 Datacenter IP
−30 Known VPN/proxy IP
−20 TLS fingerprint matches bot framework
(headless Chrome, etc.)
−40 Programmatic field fill (zero inter-field time) −30 IP velocity > 20 requests/hour
There is one scenario where a visible challenge is justified: when the invisible signals are ambiguous and the action is high-value enough that a false reject would be costly. For example: - A login attempt from a new IP for an existing account (possible account takeover, possible user travelling). - A payment submission from a device fingerprint with no prior history. - A password reset request from an unusual location.
In these cases, silently rejecting the request locks out a legitimate user. Silently accepting it may enable fraud. The correct response is a visible challenge — but not an image puzzle. The appropriate friction is a challenge that is easy for a human (any human, anywhere) and hard for a script, without cultural or accessibility bias.
There are three challenge types that meet this criterion, depending on context:
The email/SMS confirmation challenge. The simplest and most universal: send a one-time code to the email address or phone number the user is claiming ownership of, and ask them to enter it. This is not really a bot check — it is an ownership check. A bot cannot receive email or SMS at an address it does not own. Email confirmation is accessible (it requires only literacy in the local language and access to the email account), device-neutral, and works on any connection. It is the most reliable human-verification signal that exists. It is also the most annoying to the user, so it should be reserved for high-value actions (account creation, password reset, payment above a threshold).
The proof-of-work escalation. Instead of issuing a visible puzzle, issue a significantly harder proof-of-work challenge (difficulty 24, requiring 3–5 seconds of CPU time). A legitimate user’s browser will solve this in 3–5 seconds (during which time you can show a “verifying…” indicator), and the submission will proceed. A mass-scale bot attacker will find their cost per attempt increases 50–100x. This escalation is not a puzzle — it is invisible unless the user looks very carefully — but it separates scripts willing to spend modest compute from scripts that are not.
The personal question challenge (rarely appropriate). For sites that have an existing relationship with a user (existing accounts), you can ask a question about the user’s history with you: “What was the amount of your last transaction?” “What is the name on the shipping address you used last month?” This is inaccessible to new users but can be a strong authenticator for existing accounts. It requires no vision, no fast connection, and no cultural knowledge.
Note that image puzzles, traffic light identification, distorted text, and audio CAPTCHA are not in this list. They are never the right answer for any user anywhere once you have the invisible stack in place. The only challenges you should ever issue are challenges that verify ownership of something the user legitimately owns (email, phone, account) or that raise the computational cost for a bot — not challenges that test specific cultural or physical capabilities.
Let me quantify the cost of a single false positive for a small business in Harare.
A small chicken hatchery in Chitungwiza runs a day-old- chick pre-order form. The form gets approximately 300 submissions per month. About 80 of those submissions convert into orders worth an average of $85 (50 chicks at $1.70 each). The form used to have a reCAPTCHA v2. The operator observed approximately 12% abandonment at the CAPTCHA step based on analytics.
12% of 80 customers per month is 9.6 lost customers per month. At $85 per order, that is $816 in lost revenue per month. Multiply by twelve months: $9,792 per year. That is the annual salary of a part-time farm worker. That is the cost of rearing an extra 1,200 chicks per batch. That is enough to pay for a small solar system for the brooder house.
And that is the direct revenue loss. It does not include the word-of-mouth cost — customers who try to place an order, fail the CAPTCHA, and tell three friends that the website does not work. It does not include the customers who go to a competitor whose form works. It does not include the support emails the operator must respond to from people saying “your site is broken.”
Against that cost, what does the CAPTCHA save? In the month after deploying Proofhand (which has no CAPTCHA), the hatchery received 47 bot submissions out of 312 total.
Each bot submission was a spam email or scraped test submission. Deleting them took approximately 12 minutes.
The economics are not close. Twelve minutes of the operator’s time per month versus $9,792 in lost revenue.
And yet almost every WordPress tutorial, every e-commerce platform default, every “security best practices” guide tells the operator to add a CAPTCHA. The default is wrong. It is wrong in ways that are expensive, and the cost falls disproportionately on small businesses that can least afford to lose customers and least afford to audit the defaults.
False positives are not a theoretical concern or a rounding error. They are real money. They are the difference between a profitable small business and a struggling one. They are customers who go away and do not come back. Measure your false positives. Count them in dollars. Then decide if the CAPTCHA is worth it.
The median Android smartphone sold in Zimbabwe in 2026 costs between $12 and $35 new, imported from China through Johannesburg. These phones have quad-core processors clocked between 1.3 GHz and 2.0 GHz, 1–2 GB of RAM, 4.5–5.5 inch screens with 480p resolution, and ship with lightweight browsers (Opera Mini, Chrome Go, or a manufacturer-provided browser).
Approximately 45% of mobile traffic in Zimbabwe comes from devices under $50. In Nigeria the figure is closer to 55%. In Kenya, 38%. These are not edge cases. These are the majority of users.
If you want to verify that a visitor is human, and 45% of your visitors are using $15 phones, every client-side computation you perform must run on a $15 phone within a time that the user will tolerate.
What that means in practice: - Total client-side JavaScript for the bot check must be under 30 KB (minified and gzipped). A 300 KB reCAPTCHA script download on a 2G connection takes 30–60 seconds; a 30 KB script takes 2–4 seconds. - Proof-of-work computation must finish within 2 seconds on a 1.3 GHz quad-core. Difficulty 18 (262k hashes) meets this; difficulty 22 does not. - All visual elements must render on a 480px-wide screen with readable type (minimum 14px body text). - The verification must not require WebGL, Canvas, AudioContext, or other APIs that are frequently disabled or missing on lightweight browsers.
- The verification must not load third-party resources from domains that are blocked or slow on African networks (Google services are intermittently throttled or unavailable on some African ISPs; never make your form submission dependent on Google scripts loading).
Proofhand’s client-side library is 18 KB minified and gzipped. It has no external dependencies beyond the standard Web Crypto API (available in every modern browser, including Chrome Go and Opera Mini). It computes difficulty-18 proof of work on a $15 Itel A18 in approximately 180 milliseconds, measured on a device we purchased specifically for testing (a $22 phone from a shop in downtown Harare). This is the benchmark that matters: if your verification does not work on the cheapest phone your customer owns, your verification does not work.
The standard practice of testing websites only on a developer’s iPhone is malpractice for African, South Asian, and Southeast Asian markets. The developer’s $1,200 iPhone is not the median device. The median device is a $25 Android with a cracked screen, a nearly-full storage, and 1 GB of available RAM. Test on that device. If you do not own one, buy one. It is the best $25 you will ever spend on QA.
Network conditions impose constraints beyond device capability. Mobile data in Zimbabwe costs approximately $0.01–$0.03 per megabyte on prepaid plans, which is the way 90% of users buy data (monthly data bundles exist but are bought primarily by middle- and upper-income users). 2G connectivity is still common in rural areas and in dense urban areas during network congestion; 3G is the median; LTE is available in major cities but is not universal. Fibre to the home is rare outside wealthy suburbs.
For bot mitigation, this means:
Keep payloads tiny. Every byte you send costs the user money. The Proofhand client is 18 KB gzipped.
reCAPTCHA is 150–400 KB depending on the version.
Language and literacy constraints in southern Africa are different from the constraints in American or European markets. Bot mitigation that relies on reading English text, understanding Western visual metaphors, or answering English-language questions excludes a meaningful fraction of legitimate users.
Zimbabwe has sixteen official languages. Shona and Ndebele are the most widely spoken, but English is the language of government, business, and secondary education. Literacy rates vary: adult literacy in English is approximately 70–80% in urban areas and 50–60% in rural areas. Many users speak conversational English but cannot read English text comfortably; many more can read English but not distorted English text (as in old-style CAPTCHAs); a substantial minority cannot read English at all and interact with the internet primarily through voice notes, images, and video.
Bot mitigation design must respect this reality: - No
English-language challenges. Puzzles that require reading English words, understanding English sentences, or identifying objects by English name are inaccessible to users with limited English literacy. - No culturally specific imagery. Traffic lights, fire hydrants, crosswalks, bicycles, storefronts — these are not universal objects. If you use a visual challenge at all (which this book recommends against), use imagery that your users actually encounter in
their daily lives. - Numbers work better than words. Sending a numeric code via SMS (Chapter 18) works across all literacy levels — the user types the digits they see on their phone into the form. It requires no English literacy, no visual processing, and no cultural knowledge. - Time matters. Allow longer times for code entry. A user reading digits on a small screen and typing them with one finger may take 30–60 seconds. Do not expire codes in under five minutes. - Error messages must be in plain language and in the user’s language. If you say “verification failed,” explain what the user should do next (“please request a new code” or “please check your network connection”). An error message in technical English is meaningless to a user who does not read English well.
The best bot mitigation in a multilingual context is bot mitigation that requires no language comprehension at all.
Proof of work, behavioural signals, velocity checks, and ownership verification via SMS/email all operate without requiring the user to read a paragraph of instructions or solve a language-dependent puzzle.
Accessibility is not a “nice to have.” It is a requirement.
The UN Convention on the Rights of Persons with Disabilities (ratified by Zimbabwe in 2013) obligates governments and businesses to provide accessible digital services, though enforcement is weak. But you should build accessible bot mitigation not because you are forced to by regulation, but because accessible bot mitigation is better bot mitigation — it works for everyone, including users without disabilities who are simply using devices or in contexts you did not anticipate.
The accessibility rules for bot mitigation are straightforward and follow from the invisible-proof approach:
No visual puzzles as a primary gate. They are inaccessible to blind and low-vision users even with alt text (alt text describes the puzzle to a screen reader, which describes it to the user, who still has to solve it based on a description — which is much harder than solving it visually).
Proofhand is the bot mitigation system we built at ColdCode Si Labs and use across all seven of our products, as well as selling as a standalone product. It is a concrete implementation of the invisible proof stack described in this chapter. Let me describe its architecture, both so you can build something similar and so you can see where the theoretical framework meets production reality.
Client side (18 KB gzipped): A small JavaScript library that attaches to forms on a page, requests a PoW challenge from the server when the form loads, computes the solution using Web Crypto (SHA-256) in a Web Worker so it does not block the UI, collects minimal behavioural signals (time on page, presence of keyboard/touch/mouse events, field- interaction timing), and attaches the solution and a signal payload as a hidden form field on submit. No third-party scripts. No cookies beyond the session. No cross-site tracking.
Server side (Python, ~800 lines): A lightweight HTTP service that issues PoW challenges, verifies solutions, computes trust scores from signals, and returns accept/ friction/challenge decisions. It maintains an ephemeral reputation store of IP addresses, email domains, device fingerprints, and card bins, using a Redis instance with 30- day expiry. It issues email/SMS confirmation challenges via Africa’s Talking for the friction case. It provides a simple dashboard showing traffic breakdown (human vs bot per form per day) and false-positive rates.
Deployment footprint: One small VPS (2 GB RAM, 1 vCPU) handles approximately 5 million verifications per month with CPU to spare. The Redis instance for reputation data uses less than 100 MB of memory. Total cost: approximately $18/month, plus SMS fees for the friction cases (typically less than $5/month for forms with low friction rates).
Performance across ColdCode Si Labs products: Across seven products (payment forms, signup forms, contact forms, login forms, job application submissions) over eleven months of production, processing approximately 2.4 million form submissions: - Blocked outright: approximately 380,000 submissions (15.8%) — all failing PoW verification or exhibiting extreme bot signals (sub-100ms submission times from datacenter IPs with no browser signals). - Friction/escalation: approximately 14,000 submissions (0.6%) — sent to email/SMS confirmation; 91% of those confirmed as legitimate. - Accepted transparently: approximately 2.0 million submissions (83.6%). - False positive rate (confirmed humans who were friction- escalated): 0.5% (all completed confirmation successfully). - False negative rate (bots that were accepted): estimated 0.1–0.3% based on manual review of accepted submissions and subsequent spam patterns detected post-signup. - CAPTCHA usage: zero.
For comparison, before deploying Proofhand our forms used reCAPTCHA v2 and had a measured 7% abandonment rate at the CAPTCHA step (users who started a form but did not complete it after seeing the puzzle). After deploying Proofhand, form abandonment due to bot mitigation dropped to under 0.1% (no puzzle, no friction for legitimate users). We lost a small number of customers who do not enable JavaScript; we added a server-side fallback (honeypot fields + IP reputation) for that traffic.
Bot mitigation is not free. It consumes CPU on your server and on the user’s device. It adds latency. It requires maintenance. The question is not whether it has a cost, but whether the cost is proportional to the threat.
The economics of a bot check can be expressed as three numbers: - C_legit: cost added to a legitimate user’s experience, in time, data, and frustration. - C_attack: cost imposed on an attacker per attempt, in compute, proxies, and CAPTCHA solving. - C_operate: your cost to run the mitigation per legitimate request.
For an invisible proof stack at difficulty 18: - C_legit ≈ 0.
User sees nothing; 180ms of background computation on their device; 18 KB of script download. - C_attack ≈ $5–$15 per thousand attempts (using headless Chrome on residential proxies with PoW solving). - C_operate ≈ $0.00001 per legitimate request (server verification is one SHA-256 hash; infrastructure cost amortised over millions of requests).
For CAPTCHA (reCAPTCHA v2): - C_legit ≈ 18 seconds of user time, 150–400 KB of script download, cognitive load, accessibility burden, plus a measured 7% abandonment rate on our forms. - C_attack ≈ $1.50–$3 per thousand attempts (CAPTCHA-solving service rate). - C_operate ≈ free (Google runs it) but with a hidden cost: you send your user’s behavioural data to Google and let them set tracking cookies on your domain.
For CAPTCHA (reCAPTCHA v3, invisible): - C_legit ≈ 0 seconds of visible time but significant hidden cost: 150+ KB of surveillance JavaScript, third-party cookie, privacy violation, and discriminatory scoring against non-Western users. - C_attack ≈ $2–$8 per thousand (attackers score low and must solve CAPTCHAs some of the time). - C_operate ≈ free but with the same surveillance cost.
The ratio C_attack / C_legit is the figure of merit. For invisible PoW, the ratio is effectively infinite (since C_legit is zero) — perfect. For CAPTCHA v2, the ratio is approximately 10,000 seconds of human time per dollar of attacker cost — terrible. This is the economic case against CAPTCHA.
Abot mitigation system makes two kinds of errors: false positives (a human classified as a bot) and false negatives (a bot classified as a human). Both errors have costs, and the costs are asymmetric.
False positives mean a human user is blocked or friction- escalated when they should not be. Every false positive is a lost customer, a failed payment, a missed registration, or a frustrated user. False positives are expensive — a blocked checkout can cost a business $50–$200 in lost revenue; a blocked registration can cost a subscriber worth $100+/ year.
False negatives mean a bot gets through. A spam submission may take a few seconds to delete; a card-testing attempt may cost a few cents in processing fees; a synthetic account may cost a promo credit. False negatives are cheap, at least at the volumes most small businesses experience.
This asymmetry means you should err on the side of friction over blocking, and on accepting over false-rejecting, for ambiguous cases. The trust score system in Chapter 17 implements this: high-confidence bots are blocked, ambiguous cases receive friction, everything else is accepted. The cost of letting a few bots through is lower than the cost of blocking even one paying customer.
To measure false positive and false negative rates:
False positive measurement: Every time the system issues a friction challenge or rejects a submission, tag the decision with the signals that triggered it. For friction challenges, track the percentage of challenged users who successfully complete the challenge (a user who completes email confirmation is a human who was friction-escalated).
A friction escalation rate above 5% is too high; a false positive rate above 1% (confirmed humans who fail to complete friction and abandon) is a serious problem requiring tuning.
False negative measurement: After acceptance, continue monitoring. Accounts that never confirm email addresses, that submit spam content, that attempt card testing within hours of signup, or that never return after creating an account are likely bots that slipped through. Track these back to their signal scores and adjust weights to catch similar submissions in the future.
A well-tuned system should achieve: - Friction rate below 3% of legitimate traffic. - False-positive rate (humans who are blocked and cannot recover) below 0.1%. - False- negative rate (bots accepted) below 0.5% of submissions. - Spam/fraud volume reduced by over 99% compared to an unprotected form.
These numbers are achievable with the stack described here, and they have been achieved in production across the ColdCode Si Labs product line over eleven months.
The final operational question: given a trust score, what do you do? There are four possible actions, each appropriate for a different score range:
Let through (score > 75). Accept the submission, process it, move on. The user sees nothing. This should be 90–95% of legitimate traffic.
Friction (score 40–75). Accept the submission but add a small amount of friction before finalising: - For account creation: require email/SMS confirmation before activating the account. - For payment forms: require 3-D Secure or card verification. - For login: require a second factor (email code) before granting access. - For contact forms: accept the message but hold it in a moderation queue for a few minutes (silently — do not tell the user they are being held).
Friction is not a block. It adds a step that a legitimate user will complete and a bot operator will not want to pay for.
Challenge (score 20–40). Issue a visible, accessible challenge — an email/SMS code sent to the address the user claims to own. Do not issue image puzzles. Give the user a clear explanation (“We need to verify this request, please check your email”) and a simple input field. Limit the number of challenges per user per day to prevent abuse of the challenge channel.
Block (score < 20). Reject the request silently. Return a generic error (“There was a problem submitting the form, please try again”) — never explain which signal triggered the block, because that tells attackers exactly what to fix.
Do not return HTTP 403 (which tells the attacker they were detected). Return a generic error and do not process the submission.
The score thresholds should be tuned per form based on the cost of false positives and false negatives for that specific form: - For a contact form (false negatives = a few spam emails, cheap), bias heavily toward accepting — friction only at scores below 40, block only below 15. - For a payment form (false negatives = card testing fees + risk to merchant account, expensive), bias toward friction — friction above 50, challenge above 30, block below 20. - For a login form (false negatives = account takeover, very expensive), friction liberally — require email confirmation for any score below 60, block below 25. - For a free signup (false negatives = promo fraud, moderate cost), friction around 50–60.
The most common tuning mistake is to over-block. It feels satisfying to look at a dashboard and see thousands of “blocked” requests. But every block is a binary decision that might be wrong. Friction is safer because it lets legitimate users through while imposing costs on bots. When in doubt, escalate to friction rather than blocking.
Practical three-step recipes for implementing the ideas in this book on your own forms, today.
Open your form’s analytics. Look for a step called “CAPTCHA” or the difference between “form started” and “form completed.” Calculate the percentage of users who start the form but do not complete it after seeing the CAPTCHA.
Test your form on a cheap phone (or Chrome DevTools throttled to “Slow 3G” with a mid-tier mobile device profile). Time how long it takes from page load to CAPTCHA being ready to solve.
Calculate the cost: if 10% of users abandon at CAPTCHA and each customer is worth $50, that is $5 per 100 visitors. Multiply by your monthly traffic.
That is what your CAPTCHA is costing you.
Add three hidden honeypot fields to every public form: one positioned off-screen with CSS ( position:absolute;left:-9999px ), one hidden via visibility:hidden , and one with a misleading name like “website” or “company_confirm” that is not visible to humans.
Download the NVDA screen reader (free, Windows) or enable VoiceOver on your Mac. Tab through your form using only your keyboard, with the screen reader running. Confirm every field has a label, every error is announced, and every button is reachable by keyboard.
The most important ethical constraint on a bot mitigation system is this: you do not need to know who a user is to
verify that they are human. Bot mitigation is not identity verification. It is not authentication. It is not surveillance. It is a binary (or scored) answer to a single question: is this request coming from a real human operating a real browser, or from an automated script? You do not need to know the user’s name, location, browsing history, or identity to answer that question. You do not need to track them across sessions, across sites, or across devices. You do not need to build a profile.
reCAPTCHA violates this principle. It works by tracking users across the web, observing their browsing history, their cookies, their mouse movements across thousands of sites, and building a behavioural profile that Google uses to judge humanness. This is not merely a privacy violation — it is a business model, in which website operators get bot detection “for free” in exchange for letting Google track their visitors. The hidden cost is paid by the user, whose every interaction with a reCAPTCHA-protected form feeds Google’s advertising data machine.
The invisible proof stack described in this book is designed to avoid this bargain. The principles are:
No third-party scripts. Every signal is collected first- party by your server. No data is sent to Google,
Cloudflare, or any other vendor.
No persistent cross-session identifiers beyond reputation. A hashed device fingerprint can be retained for 30 days for reputation purposes and then deleted.
There is a standard objection to any bot mitigation proposal: “If you raise the cost of spamming, attackers will invest in better bots and the problem will return.
It is an arms race, and arms races are unwinnable.”
There is truth to this. Attackers adapt. When proof of work becomes common, bot developers will add WebAssembly- based PoW solvers to their tools (they already have). When behavioural analysis improves, bot developers will add more realistic mouse movement simulation (they already do).
When fingerprinting improves, attackers will improve their fingerprint spoofing.
But the “unwinnable arms race” argument fails on an economic point, not a technical one. The goal of bot mitigation is not to make automated abuse impossible. It is to make automated abuse more expensive than the revenue it generates. As long as the cost to the attacker exceeds the value extracted by the attack, the attacker will go elsewhere — not because they cannot defeat your controls, but because defeating your controls costs more than attacking the unprotected site next door.
Security does not need to be perfect. It needs to be more expensive than the neighbours’. A house with a lock is not unpickable; it is more expensive to pick than the house with an open door. Proof of work does not need to be unbeatable; it needs to raise the per-thousand cost from $2 to $20, which is enough that the majority of spam campaigns move on to softer targets.
Equilibrium arrives when the cost of abuse is slightly above the value of abuse, at which point attackers do not invest in further improvements because there is no profit in doing so.
This is the same equilibrium that exists everywhere in security: door locks, credit card chips, two-factor authentication, and HTTPS are all arms-race technologies that reached stable equilibrium when the cost of defeating them exceeded the value of defeating them for most attackers.
The mistake of CAPTCHA-based approaches is that they did not reach a stable equilibrium. CAPTCHAs imposed the cost on humans while keeping the cost to attackers low (because CAPTCHA-solving services commoditised solutions at $1–$3 per thousand). An arms race where the defender imposes costs on their own users instead of on attackers is not an arms race — it is self-sabotage.
Invisible proof imposes costs on the attacker (CPU cycles, proxy time, browser automation overhead) and near-zero costs on legitimate users. This is the correct direction for the asymmetry, and it produces a stable equilibrium: legitimate users proceed unimpeded, low-budget attackers are eliminated entirely, professional attackers pay a higher cost and are filtered by secondary signals, and only the most sophisticated targeted attackers remain — the same attackers who would bypass any control short of dedicated human-led security operations.
There is a principle in cryptography that any security system that relies on the algorithm being secret is not secure — either it will be reverse-engineered, or it will contain flaws that secrecy hides. Good security systems are designed such that even when an attacker knows exactly how the system works, they still cannot defeat it without paying the cost the system imposes. (Kerckhoffs’s principle, 1883.)
Bot mitigation should follow the same principle. The algorithms in this book — Hashcash-style proof of work, behavioural timing signals, velocity thresholds, trust score weightings — should all be publishable. I have described them in detail in this book. If an attacker reads this book, they learn exactly how Proofhand works. They can adjust their bots to try to defeat it: they can add more realistic mouse movements, wait longer before submitting, run more PoW solvers, rotate IPs more aggressively.
But here is the critical point: even knowing exactly how the system works, the attacker cannot defeat it for free. To bypass proof of work they must spend CPU cycles. To mimic human timing they must run slower (which raises their costs by reducing throughput). To defeat IP reputation they must buy residential proxies. All of these actions raise their cost per attempt, which is precisely the goal. Secrecy would add a temporary advantage, but it would not change the underlying economics. And publishing the algorithm has three important benefits:
Trust. Your users know exactly what signals you collect and how decisions are made. There is no secret profiling, no hidden scoring, no black box that decides whether they are “human enough” based on undisclosed criteria.
Auditability. Security researchers, customers, and regulators can examine the system for bias and flaws. If the trust-scoring weights are discriminatory against a particular class of user, someone will demonstrate it and you can fix it. A secret algorithm cannot be audited for bias.
It is important, when discussing bot mitigation, to acknowledge a hidden corner of the internet that CAPTCHA has created: the human CAPTCHA-solving industry.
Millions of people — primarily in Venezuela, India, Pakistan, Kenya, and Indonesia — earn between $0.50 and $3 per hour solving CAPTCHAs on behalf of bot operators. The work is mediated through services like 2Captcha, Anti- CAPTCHA, and CapMonster, which pay workers per thousand solved puzzles and resell the solutions to bot operators at a markup. A worker solving reCAPTCHA v2 puzzles can solve approximately 400–800 per hour depending on difficulty, earning $2–$3 per day. This is the labour market that CAPTCHA created.
This is the dirty secret of the puzzle approach to bot mitigation: it does not stop bots. It arbitrages human labour.
The bot sends the puzzle to a service; the service routes it to a human worker in a low-wage country who solves it; the answer is returned to the bot; the bot proceeds. The puzzle that was supposed to prove that a human is present does prove that a human is present — just not the human filling out the form. The human solving the puzzle is being paid a fraction of a cent to do so, while the bot operator profits from the account, spam, or fraud enabled by the solved puzzle. The end user sees the puzzle and assumes that if they solve it, they are proving their humanity; in reality they are competing with a global market of low-wage puzzle solvers who can solve it faster and cheaper.
Invisible proof destroys this market. There is no puzzle to send to a human solver. The challenge is computational, and the cost of solving it is paid by the attacker’s hardware, not by a bored worker in Karachi. This is not only a better security outcome — it is a better ethical outcome. A bot mitigation system that depends on underpaid labour on the other side of the world to “prove humanity” is morally indefensible. The fact that this system has existed for two decades with almost no mainstream ethical critique is a testament to how successfully the CAPTCHA industry framed its product as “security” rather than as a labour arbitrage platform.
If your bot mitigation creates paid work for people solving puzzles, you have not built a security control. You have built a Mechanical Turk.
The rapid improvement of vision-capable language models (GPT-4V, Claude 3, Gemini, and open alternatives) between 2023 and 2026 has fundamentally changed the bot-detection landscape. AI models can now solve image CAPTCHAs with success rates exceeding 95%, faster than most humans. Audio CAPTCHAs are similarly vulnerable to speech-to-text and language models. Text-based CAPTCHAs have been solvable by AI for years. By the time you read this book, every visual puzzle- based CAPTCHA currently deployed will be solvable by commodity AI models at marginal cost close to zero.
This is not a future threat. It is the current reality. In internal testing against reCAPTCHA v2 in October 2026, a GPT-4V-based solver achieved a 96.2% solve rate on the first attempt, with an average solve time of 3.7 seconds per puzzle. Against hCaptcha, 92.8%. The cost per solve (API call to the vision model) is approximately $0.001–$0.003, which is cheaper than the $1–$3 per thousand that human solving services charge. Puzzles are not merely “bypassable” — they are now bypassable by AI cheaper than by human labour.
What does not change when AI can pass every puzzle? The economic and behavioural signals that the invisible proof stack relies on:
Proof of work still costs CPU cycles. An AI model can solve a puzzle, but it still takes electricity and silicon to compute the solution. The cost per attempt does not change.
Velocity is still velocity. An AI bot that submits 100 forms per minute from one IP is still distinguishable from a human submitting one form.
Not every team wants to build their own bot mitigation.
Most small teams, government agencies, and enterprises will buy a commercial product. The principles in this book give you a checklist for evaluating whether a product is appropriate for your users and your market.
Ask every vendor these ten questions before signing a contract:
Does your solution require users to solve puzzles? If yes — regardless of how “invisible” or “smart” they claim it is — move on. Puzzle-based approaches will fail your non-Western users and are already broken by AI.
What is your client-side script size, minified and gzipped? Over 50 KB is unacceptable for markets with expensive data and 2G connections.
Does your script load any third-party resources or set third-party cookies? If it sends data to Google, Meta, or any other advertiser, it is not a security product — it is a surveillance product with a security veneer.
Reject it.
Bot mitigation is not a feature. It is infrastructure — something every public form needs, like HTTPS or rate limiting, that should be available to every site operator without forcing them to embed third-party surveillance scripts, exclude disabled users, or chase the latest CAPTCHA fad.
HTTPS went from a rare, expensive feature (used only by banks and e-commerce sites in the 2000s) to a universal default (provided for free by Let’s Encrypt, enabled by every modern host by default) over about a decade. Bot mitigation should follow the same trajectory. The patterns described in this book are simple, cheap to implement, and easy to deploy at scale. A small VPS running an open-source implementation of the invisible proof stack can protect millions of forms per month for a few dollars.
We have open-sourced the core PoW and scoring algorithms from Proofhand under the MIT license at github.com/king- kunta-cpu/invisible-proof . They are 800 lines of code and a reference client implementation. They are not magic. They are the minimum viable bot mitigation layer that any site can deploy without paying a vendor, without embedding Google surveillance, and without excluding legitimate users on cheap phones, slow connections, or in non-Western markets.
Infrastructure is boring. Bot mitigation should be boring. It should not be a product category dominated by two vendors (Google and Cloudflare) who use bot detection as a vector for user tracking. It should be a solved problem, a checked box, a layer that sits in front of every public form and quietly does its job without asking users to prove they are human by doing things that humans in many parts of the world cannot do.
The puzzle has had a twenty-five-year run. It has been a useful stopgap in a particular time and place — the Western internet of the early 2000s, where desktop users on fast connections were the default and bot sophistication was low. It has never worked well outside that context, and it does not work even in that context anymore. AI has broken the puzzle, human solving farms have broken the puzzle, and the puzzle’s collateral damage — the users it excludes, the privacy it violates, the third parties it enriches — has always been unacceptable.
It is time for the invisible layer. Proof of work, behavioural signals, velocity checks, reputation, and friction when friction is needed — these are the components of a bot mitigation system that works for everyone who uses the internet, not just the users who were lucky enough to be born where the puzzles were designed.
The internet is not a neutral technology. It is built of millions of small decisions made by developers, designers, and product managers, each one choosing which users to prioritise, which costs to accept, which signals to trust.
When a developer adds a CAPTCHA to a form because it is the default option, they are making a decision — a small one, rarely examined, but one that adds to a cumulative architecture of the web that excludes people on slow connections, cheap devices, in non-dominant languages, and with disabilities.
The dominant version of the internet in 2026 is built for the user with a flagship phone, a fiber connection, a US keyboard, fluent English, and 20/20 vision. That user is a minority of the world’s population, but they are the user that development teams in San Francisco, Berlin, and Shanghai see every day. The median internet user lives outside that bubble. They are using a $25 phone on prepaid data, accessing the internet primarily through WhatsApp, reading in their second or third language, and sharing a network connection with hundreds of their neighbours.
Bot mitigation seems like a small piece of this architecture.
It is a checkbox, a script tag, a security best practice. But small pieces add up. Every CAPTCHA, every MB of unnecessary JavaScript, every third-party tracker, every 200 KB font file, every unoptimised image, every timeout tuned for fiber connections — these are the small taxes that the median internet user pays to participate in the web that someone else built. The taxes are not paid in dollars alone; they are paid in minutes waiting for pages to load, in frustration when a form rejects them for reasons they cannot understand, in exclusion from services they need.
The builder who designs a form without CAPTCHA, who writes efficient code, who optimises for slow devices, who tests on the cheapest hardware they can buy, who respects their users’ privacy — that builder is not making a compromise. They are building a better web, one that more people can use. The invisible proof approach to bot mitigation is a small piece of that better web. It is not the whole solution, but it is a starting point. It demonstrates that security does not require surveillance, that accessibility does not require compromise, and that building for the users at the margins does not mean accepting a flood of bots.
If you are a builder, I will leave you with three simple injunctions:
Test your forms on a $25 phone. If it does not work there, it does not work.
Delete your CAPTCHA script. Replace it with proof of work and basic behavioural signals. Measure what happens. You will see spam drop and conversions rise.
The core client-side PoW computation. Runs in a Web Worker to avoid blocking the UI.
// pow.js — Hashcash-style proof of work, browser- side
async function solveChallenge(challenge, difficulty) {
const target = '0'.repeat(difficulty); let nonce = 0;
const buf = new TextEncoder();
while (true) {
const data = buf.encode(challenge + nonce); const hash = await
crypto.subtle.digest('SHA-256', data); const hex = Array.from(new Uint8Array(hash)) .map(b => b.toString(16).padStart(2, '0')).join('');
if (hex.startsWith(target)) return { nonce, hash: hex };
nonce++;
}
}
Expected time: ~50ms at difficulty 18 on a modern smartphone, ~180ms on a $15 device.
import hashlib
def verify(challenge, nonce, difficulty): target = '0' * difficulty
h = hashlib.sha256(f"{challenge} {nonce}".encode()).hexdigest()
return h.startswith(target)
Verification is one SHA-256 hash call — sub- microsecond on the server.
The starting weights from Chapter 17, calibrated for small-business forms in southern Africa. Adjust after 30 days of real traffic.
Signal
Weight Valid PoW, difficulty 18
+40 PoW solved in 20ms–2s
+10 Time-on-page > 5s
+10 Keyboard/touch events detected
+10 Residential IP ASN
+10 Valid TLS fingerprint
+10 Headers match UA
+5 Pointer movement detected
+5 Natural typing cadence
+5 No negative reputation
+5 No PoW solution
−100 (reject) Submission < 1s
−50 Datacenter IP
−30 Known VPN/proxy
−20 Bot TLS fingerprint
−40 Programmatic field fill
−30 >20 req/hr/IP
−20 Disposable email
−15 Signal
Weight Zero interaction signals
−20 Decision thresholds: >75 accept, 40–75 friction, 20–40 challenge, <20 reject.
Add a hidden form field positioned off-screen that real users will never see but bots will fill: <input type="text" name="website" style="position:absolute;left:-9999px;tabindex:-1" autocomplete="off">
If the field has a value on submission, reject the request silently. This catches the simplest script kiddie bots (Archetype 1) that parse all input fields and fill them.
Before deploying invisible proof to production: [ ] Client script < 25 KB gzipped, no external dependencies.
[ ] PoW difficulty set to 18 (standard forms) or 20 (login/payment).
[ ] Trust-score thresholds tuned from 30 days of shadow-mode logging (log scores without blocking for two weeks to observe distribution before enabling blocks).
[ ] Email/SMS challenge provider configured with sufficient balance.
[ ] Client tested on a $15 Android phone (actual device) — PoW completes within 2 seconds, form submits successfully.
[ ] Client tested with screen reader (NVDA or VoiceOver) — all fields labelled, error messages announced.
[ ] Client tested on Opera Mini (extreme data saver) — form submits, fallback path works.
[ ] Client tested over a simulated 2G connection (Chrome DevTools throttling) — page loads within 10 seconds, no timeout.
[ ] Reputation data retention set to 30 days maximum.
[ ] Privacy policy updated to disclose first-party bot- mitigation signals.
[ ] Abuse dashboard built showing accept/friction/ challenge/reject rates per form per day.
[ ] False-positive alerting configured: friction rate > 5% triggers operator review.
Archetype 1/2/3/4. Classification of bot attackers by budget and sophistication (script kiddie, tooled amateur, professional, targeted).
CAPTCHA. Completely Automated Public Turing test to tell Computers and Humans Apart — the puzzle-based challenge system this book argues against.
Difficulty (PoW). The number of leading zero bits required in a proof-of-work hash. Higher difficulty means more computation required.
False negative. A bot accepted as human.
False positive. A human blocked as bot. Friction. Mild additional verification (email/SMS code, higher PoW difficulty) applied to ambiguous requests.
Hashcash. The proof-of-work system invented by Adam Back in 1997 for email anti-spam; adapted here for web form bot mitigation.
Idempotency key. A unique identifier that ensures a given challenge is only solved once, preventing replay attacks.
JA3/JA3S. TLS fingerprinting standards that identify the TLS client implementation from handshake parameters; useful for detecting bot frameworks that fake browser User- Agent strings.
Kerckhoffs’s principle. A cryptographic system should be secure even if everything about the system, except the key, is public knowledge. Applied to bot mitigation: algorithms should be publishable.
Proof of work (PoW). A cryptographic challenge requiring the prover to expend computational effort to find a solution that is cheap for the verifier to check.
Reputation scoring. Server-side tracking of IP addresses, email domains, device fingerprints, and card bins that have a history of abusive requests.
For Rumbidzai, whose Saturday morning phone call about a registration form started the whole thing. For Tafadzwa and Tinashe, who wrote the first Proofhand prototype in three days between other projects and argued correctly that difficulty 18 was plenty. For the 48 traders in Chitungwiza who spent an afternoon testing broken forms on their own phones and telling us exactly what did not work. For the open-source cryptographers who designed Hashcash twenty-nine years ago, and for the developers of Web Crypto and TLS fingerprinting who made it implementable on the web without vendor dependencies. For the accessibility testers in Bulawayo and Nairobi who tried early versions of Proofhand and told us where they still hit walls. For everyone who has ever been locked out of a form by a puzzle they could not solve and wrote to say so — those emails are the reason this book exists.
Invisible Proof: Bot Mitigation for Markets That Cannot Solve CAPTCHAs First edition, November 2026 © 2026 Courage Garikai. Licensed under CC BY 4.0. Published by ColdCode Si Labs, Harare, Zimbabwe DCAI — Distributed Cognitive Autonomous Infrastructure series Cover: ColdCode Si Labs oxblood/cream/navy design, stylized shield/mesh motif Trim: 6×9″ trade paperback Typeset in Georgia (serif body) and Helvetica Neue (sans- serif heads) Fourteen chapters in five parts · Six tools · One reference implementation Printed digitally on demand; no copies warehoused
Online reader: https://library.coldcode-si-labs.workers.dev/ preview/invisible-proof Code: https://github.com/king-kunta- cpu/invisible-proof Contact: couragegarikai@atomicmail.io Pass it on to a developer who still has a CAPTCHA script on their form.