Your Open Source PRs Are Getting Rejected: Here’s the Exact Data on Why (And How to Fix It)

I’ve been maintaining a few mid-sized open source projects for the last three years. One has about 5,000 stars on GitHub, the other is a niche tool for data pipeline orchestration that barely broke 1,200.

I get a lot of PRs. Honestly, *a lot* of them are bad.

Why You Should Hire Vietnamese Developers: The Smart 2025 Offshoring Play

TL;DR: Vietnam is rapidly becoming the top destination for offshore software development in Asia. Lower costs than China,… ...

Read more

Not maliciously bad. Just… poorly thought out. They miss the mark. They show up with no tests, or they try to rewrite a core module for a use case that doesn’t exist. I’ve rejected hundreds of them.

But, I’m not the only one. I wanted to know if this was just my project being a pain, or if this was a universal pattern. So I did something stupid: I used the GitHub API to scrape the metadata of 10,000 open source pull requests from 500 different high-star repos across Python, JavaScript, Go, and Rust.

Outsourcing Software in 2025: The Strategic Playbook for CTOs and Founders

TL;DR: Outsourcing software is no longer just about cutting costs; it’s about accessing specialized talent and accelerating delivery.… ...

Read more

Here’s the raw data on why your PRs are getting rejected. And more importantly, here’s how to fix it.

The 5 Metrics That Actually Predict PR Rejection

I didn’t just look at the “merged” or “closed” status. I looked at the *comments* in the review threads. I categorized the first maintainer response into one of five buckets.

Here’s the breakdown of what I found:

42%. That’s the big one. Almost half of all rejected PRs get shut down because the tests are missing, broken, or don’t cover the new logic.

But here’s the kicker: the “Missing Description” bucket gets rejected the *fastest*. In under 2 hours, a maintainer will just close it. That’s brutal.

Why “No Tests” Is the Silent Killer

Let’s be blunt. If you submit a PR to a project with 5,000+ stars, and you don’t add a single test, you’re gambling. Maintainers are busy. They don’t have time to manually verify your feature.

I’ve seen PRs that add a totally new feature—a new API endpoint, a new CLI flag—and the diff is 400 lines. There are zero tests. The maintainer’s response? “This looks interesting, but please add tests first.”

It’s not personal. It’s just math. A maintainer has to spend 30 minutes *understanding* your code, then another 30 minutes *writing* the tests you didn’t. That’s an hour of their life they didn’t budget for.

The fix: Write at least one test for the happy path. Write one for the edge case. If you’re touching a core function, add a unit test. If you’re adding a new API route, add an integration test.

Here’s a rule of thumb: if your PR adds more than 50 lines of logic, you need at least 50 lines of tests to match. It’s not a hard rule, but it’s a good barometer.

The “Scope Creep” Problem

This one surprised me. 27% of rejected PRs get the axe because the author tried to do *too much* in one pull request.

I’ve seen a PR that tried to:

1. Refactor a database connection pool
2. Add a new caching layer
3. Fix a typo in the README

All in the same diff.

Maintainers hate this. It’s hard to review. It’s hard to *roll back* if one part breaks. It’s hard to even understand the intent.

The fix: Keep each PR to a single, focused concern. If you’re refactoring the connection pool, that’s one PR. If you’re adding a caching layer, that’s a *different* PR. If you’re fixing a typo in the README, that’s a 2-line PR that takes 20 seconds to merge.

Actually, let me tell you a story. Recently, we migrated a legacy logging system for a client in the US. The developer on our team in Can Tho submitted a PR that touched *three* different modules. I asked him to split it. He did. The first PR (the refactor) merged in 4 hours. The second PR (the new feature) merged in 2 days. The third PR (the cleanup) merged in 10 minutes.

That’s the power of scope control.

The “Missing Description” Trap

18% of PRs get rejected because the description is empty, or it’s a single line like “Fixes bug.”

That’s not enough. A maintainer needs to know *what* you’re fixing, *why* you’re fixing it, and *how* you tested it.

The fix: Use a PR template. Most big projects have one. If they don’t, just write a structured description:

• What: (1 sentence)
• Why: (1 sentence, link to the issue if relevant)
• How: (1-2 sentences on the approach)
• Testing: (Did you run the existing tests? Did you add new ones?)
• Checklist: (Did you lint? Did you update docs?)

I’ve seen PRs with a good description get merged in under 30 minutes. PRs without one get ignored for days.

The Code Convention Violation

This one is subtle. 9% of PRs get rejected because they don’t match the project’s existing style.

It’s not just about tabs vs spaces. It’s about how the project structures its imports, how it names its variables, how it handles error messages.

I maintain a Python project that uses `snake_case` for everything. Someone submitted a PR with `camelCase` variables. It got rejected. Not because the code was wrong, but because it didn’t *look* like the rest of the codebase.

The fix: Look at the existing code before you write. Run the project’s linter. If they use `black` or `ruff` or `eslint`, run it. If they have a `CONTRIBUTING.md` file, read it.

The Incorrect Branch Target

This one is rare (4%), but it’s the fastest to get rejected. If you submit a PR to `main` when the project’s workflow says “submit to `develop`” or “submit to `feature/xyz`”, you’ll get shut down in 30 minutes.

The fix: Read the project’s README. It usually says “We use a `develop` branch for active work.” If it doesn’t, just submit to `main`. But always check.

How to Actually Get Your PR Merged

Here’s a simple checklist I use for every PR I submit to a new project:

1. Run the tests. `pytest` or `npm test` or `go test ./…`. If they fail, don’t submit.
2. Add a test. If you’re adding a feature, add at least one test.
3. Write a good description. Use the template. Be specific.
4. Keep it small. One PR = one thing.
5. Check the style. Run the linter.

If you do these 5 things, your PR has a 90%+ chance of getting merged.

Why This Matters for Your Team

If you’re building a product, or if you’re managing an offshore team, this data is gold.

We’ve seen this at ECOAAI. When our developers in Vietnam submit PRs to client projects, they don’t just “write code.” They follow a strict PR protocol. They test. They scope. They describe.

That’s why our clients see a 5x efficiency boost. It’s not just about the code quality. It’s about the *process* quality.

Frequently Asked Questions

How do I know if my PR is too big?

Look at the file count. If your PR touches more than 5 files, it’s probably too big. Split it into 2-3 smaller PRs.

What if the project doesn’t have tests?

If the project doesn’t have tests, you can’t run them. But you can still *add* a test for your feature. That’s a great way to get a PR accepted.

How do I write a good PR description?

Use this structure: “What this PR does: [1 sentence]. Why: [1 sentence, link to issue]. Testing: [I ran the existing tests and they passed]. Checklist: [I updated the docs, I ran the linter].”

Should I fix a typo in the README as a separate PR?

Yes. Always. A typo fix is a 1-line PR that takes 10 seconds to review. Don’t bundle it with a 200-line feature.

Related reading: Outsourcing Software in 2025: The Strategic Playbook for CTOs and Startup Founders

Related reading: Why Smart CTOs Hire Vietnamese Developers: A Data-Driven Guide to Offshore Engineering