The pay-per-task developer economy: bounties, gigs, and what they realistically pay
Most ways to get paid to solve coding problems outside a salary are pay-per-task: you claim a piece of work, finish it, and get paid for that result. The pay is real but it varies a lot — by platform, by the project's funding, by difficulty, and by your track record. Treat the categories below as honest ranges and 'it varies' language, not promises.
There are roughly five buckets, and they each reward different things. Knowing which one fits your skills matters more than chasing the highest-sounding number.
- ▸Issue bounties — a maintainer or sponsor attaches a cash reward to a specific GitHub issue; you fix it, your PR merges, you get paid.
- ▸Bug bounties — security-focused programs pay for valid vulnerability reports; payouts scale with severity and can range widely.
- ▸Code-review gigs — paid review of pull requests, audits, or contracts; usually per-task or hourly.
- ▸OSS funding — recurring sponsorship, grants, and maintainer stipends for ongoing work rather than one task.
- ▸Usability and website testing — paid per completed test session, typically a flat fee per task.
Get paid to review code: where code-review gigs and PR bounties live
Getting paid to review code is real, but it's narrower than 'fix bugs' and usually depends on trust. Reviewers are paid to read pull requests, catch issues, and sign off — so projects want people with a relevant track record. The work splits into a few honest categories, each with different pay shapes.
Rather than quote numbers we can't stand behind, here's how the categories actually pay: per-task for one-off PR reviews, hourly for ongoing reviewer roles, and fixed-scope fees for audits. Smart-contract and security audits sit at the top of that range because the cost of a missed bug is high; general PR review sits lower.
- ▸Per-PR review — some bounty and freelance platforms let maintainers pay for a single reviewed pull request.
- ▸Ongoing reviewer roles — larger OSS projects and companies sometimes pay trusted contributors hourly to keep PR queues moving.
- ▸Audit work — security and smart-contract audits are paid as fixed-scope engagements and pay the most, but require deep, demonstrable expertise.
- ▸Reality check — code-review pay tracks your reputation; a stronger GitHub history and domain expertise unlock the better-paying gigs.
Get paid to fix bugs: bug-bounty and issue-bounty platforms
Fixing bugs for money comes in two flavors that people often confuse. Security bug bounties pay for finding and responsibly reporting vulnerabilities — these are 'get paid to find bugs' programs, and payouts scale with severity, from small for low-risk issues to very large for critical ones, but they're competitive and only pay for valid, novel findings. Functional issue bounties pay for fixing a specific, already-known bug or feature in a codebase — these are 'get paid to fix bugs' tasks tied to a merged pull request.
Functional bounties are the more predictable path for most developers: the work is scoped, the reward is posted up front, and payment follows a merge. Security bounties can pay more per finding but are far more variable — you might investigate for hours and find nothing payable. Pick based on your appetite for that variance.
- ▸Issue bounties — funded GitHub issues with a posted reward; claim, fix, merge, get paid.
- ▸Security bug bounties — paid per valid vulnerability report, scaled by severity; high variance, high ceiling for critical finds.
- ▸Severity matters — most security programs tier payouts by impact, so a critical, exploitable bug is worth far more than a cosmetic one.
- ▸Honest expectation — bounty income is lumpy; some months you land a fix, some months you don't.
Can you make money contributing to open source? Grants, sponsorship, and issue bounties
Yes, you can make money contributing to open source — but it's rarely automatic, and most contributors aren't paid by default. Open-source funding comes from a mix of recurring sponsorship, one-time grants, posted issue bounties, and direct maintainer stipends from companies that depend on a project. How open-source projects get funded is the same question from the other side: donations, corporate backing, foundation grants, and dual-license or paid-support business models.
If your goal is to get paid to contribute to open source specifically, the realistic on-ramps are: take funded issue bounties, build a reputation on a project until you're offered a paid maintainer role, or apply for a grant tied to specific deliverables. It compounds slowly — early contributions are usually unpaid, and the paid opportunities follow a track record. For the bigger picture on stacking developer income streams, see our roundup of side hustles for software engineers.
- ▸Sponsorship — recurring monthly support (e.g. via GitHub Sponsors) for maintainers; depends entirely on your audience and project reach.
- ▸Grants — fixed awards from foundations or companies for specific, deliverable-bound work.
- ▸Issue bounties — the most beginner-friendly paid OSS path; pick a funded issue and ship it.
- ▸Maintainer funding — some companies pay maintainers of dependencies they rely on, but these roles are earned over time.
- ▸How OSS companies make money — paid support, hosting, enterprise tiers, and dual licensing fund the open code underneath.
Get paid to test websites: usability-testing platforms and honest hourly expectations
If you want to get paid to test websites without writing code, usability-testing platforms pay you to complete short tasks — navigate a site or app, speak your thoughts aloud, and report what's confusing. You're paid a flat fee per completed test, and sessions are typically short. It's accessible and requires no GitHub profile, but it's not a steady income: tests are matched to your demographic and availability, so they arrive irregularly.
Be honest with yourself about the hourly math. Per-test fees sound fine, but throughput is the catch — you only earn when a test matches you and you qualify, so real hourly earnings depend on how many you actually land. Treat it as supplemental, task-by-task income rather than a reliable wage.
- ▸Per-task pay — a flat fee per completed usability test, not an hourly rate.
- ▸Low barrier — no portfolio or code required; good for non-developers or downtime.
- ▸Irregular supply — tests are matched to your profile, so volume is unpredictable.
- ▸Honest framing — useful as occasional side income, not a dependable monthly figure.
The always-on layer underneath all of it: earn USDC while your AI agent thinks
Every method above is active work — you claim a task, do it, and get paid. There's also one passive, opt-in layer that runs in the background while you do that paid work: claudearn. While your AI coding agent is 'Thinking…', it places a single sponsored line in the spinner for about five seconds, and you keep roughly half the ad revenue in USDC on Solana, claimable to any wallet like Phantom and verifiable on Solscan.
This is not a replacement for bounties, reviews, or grants — it's a complement. It earns from the idle seconds you were already losing while reviewing PRs or waiting on a fix to compile. The honest range is ~$15–$60/mo, varies — small, modest, and never guaranteed. It's the lowest-effort way to monetize Claude Code and Cursor while you focus on the gigs that actually move the needle. Critically, it never reads your code: the extension only renders the ad and reports that it was viewed.
- ▸Runs in the background — works while you review code, fix bugs, or contribute upstream.
- ▸Honest pay — ~$15–$60/mo, varies; complementary income, not a salary or a guarantee.
- ▸Self-custody — earnings accrue in USDC on Solana and you claim them to your own wallet.
- ▸Privacy by design — renders the sponsored line and reports a view; your source never leaves your machine.
- ▸Works across VS Code, Claude Code, Cursor, and Codex CLI.
How to combine them without burning out
Stacking earning methods only works if you don't spread yourself thin chasing every platform. The trick is to pick one or two active methods that match your strengths, then let a passive layer run underneath so your downtime isn't dead time. Active work is where the real money is; the background layer just stops you from leaving the idle seconds on the table.
A realistic, low-burnout setup looks like this: do the deep work you're good at, batch the low-effort gigs, and automate the passive layer entirely. If you want a fuller framework for layering income as a developer, our guide to getting paid to code and the piece on making money vibe coding both go deeper.
- ▸Pick a primary — choose one active method (bounties, audits, or OSS) that fits your skills, and go deep instead of wide.
- ▸Batch the rest — group usability tests or small PR reviews into dedicated blocks so they don't fragment your focus.
- ▸Automate the background — let the passive USDC layer run while you work; it needs no attention once it's on.
- ▸Protect deep work — the highest-paying gigs reward concentration, so guard it from low-value busywork.
Frequently asked questions
Do open source contributors get paid?
Most aren't paid by default — open source runs largely on unpaid contributions. But you can get paid through funded issue bounties, recurring sponsorship, grants tied to deliverables, and paid maintainer roles. Paid opportunities almost always follow a track record, so early contributions tend to be unpaid.
Can you make money contributing to open source?
Yes, but it's rarely automatic. The realistic on-ramps are taking posted issue bounties, building a reputation until you're offered a paid maintainer role, or winning a grant for specific work. It compounds slowly, and income is lumpy rather than a steady wage.
How do open source companies make money?
Open-source companies typically monetize around the free code — through paid support, managed hosting, enterprise tiers with extra features, and dual licensing. That revenue funds the open code and sometimes pays the maintainers who work on it. The open project is the funnel; the paid services are the business.
How are open source projects funded?
Through a mix of individual donations and sponsorship, corporate backing from companies that depend on the project, foundation grants, and business models like paid support or dual licensing. Larger projects often combine several of these. Funding tends to follow projects that have proven they're critical infrastructure.
Which method pays fastest?
Functional issue bounties and usability tests usually pay quickest because the scope and reward are posted up front and payment follows a merge or a completed session. Security bug bounties can pay more but are slower and higher-variance, since you only get paid for valid, novel findings. The passive USDC layer accrues continuously but in small amounts, claimable once you pass a minimum.
Do I need a big GitHub profile to get paid?
For code review and paid maintainer roles, a stronger profile genuinely helps — those gigs reward trust and demonstrable expertise. But issue bounties and usability testing have a much lower barrier, and the background USDC layer needs no profile at all. You can start small and let reputation unlock the better-paying review and audit work over time.
Does claudearn read my code?
No. The extension only renders the sponsored line in your agent's spinner and reports that an ad was viewed. Your source code, prompts, and files never leave your machine — privacy is enforced by the architecture, not just a promise.
How much can I earn from the claudearn background layer?
Roughly $15–$60 a month, and it varies with advertiser demand and how many hours you actively code. It's honest, modest side income for the idle seconds your AI agent spends thinking — not a guarantee and not a replacement for the paid gigs above. Earnings accrue in USDC on Solana and you claim them to a self-custody wallet.