How I Earn $150-$250 Per Pull Request Building Dashboard Templates

I've submitted 4 pull requests to SigNoz in the last 3 days. Each one pays $150-$250. The work? Building JSON dashboard templates — no core code changes, no complex algorithms, just structured monitoring configs.

Here's the exact workflow I use and why dashboard bounties are the most underrated way to earn from open source.

Why Dashboard Bounties?

Most open source bounties are a bloodbath. Any issue with a bounty label over $100 gets 15-40 comments within hours. Bot armies auto-comment on everything. You're competing against people who will submit half-baked PRs just to claim the bounty.

Dashboard bounties are different:

1. High barrier to entry — you need to understand the monitoring platform's schema, the target technology's metrics, and how to structure panels that operators actually use
2. Multiple rewards per issue — SigNoz rewards multiple quality submissions on the same dashboard issue (I've seen 7+ payouts on a single issue)
3. Repeatable pattern — once you learn the JSON template format, you can produce dashboards fast
4. Low competition — most bounty hunters can't be bothered with "boring" config work

The Workflow

Step 1: Find Dashboard Bounty Issues

SigNoz maintains a list of wanted dashboards in their GitHub issues. Look for issues tagged with bounty that mention "dashboard" or "monitoring template."

Other platforms with similar opportunities: Grafana, Datadog (community integrations), New Relic (quickstarts).

Step 2: Understand the Target Technology's Metrics

Before writing a single line of JSON, I research the technology the dashboard monitors. For my cert-manager dashboard (90 panels, $250 bounty), I spent 30 minutes reading:

• cert-manager's Prometheus metrics documentation
• Common certificate lifecycle events operators care about
• Alert thresholds that actually matter in production

This research phase is what separates a $250 dashboard from a rejected PR.

Step 3: Structure the Dashboard

Every good monitoring dashboard follows this hierarchy:

Overview (health at a glance)
├── Key metrics: up/down, error rate, latency
├── Resource usage: CPU, memory, connections
├── Business metrics: throughput, queue depth
└── Drill-down sections
    ├── Per-component breakdown
    ├── Error analysis
    └── Historical trends

I use a dashboard builder skill in Claude Code that generates SigNoz-compatible JSON from a metrics specification. It handles the repetitive panel structure — I focus on which metrics matter and how to lay them out.

Step 4: Build the JSON Template

Here's a simplified example of what a SigNoz dashboard panel looks like:

{
  "title": "Certificate Expiry (Days Remaining)",
  "description": "Days until certificate expires. Alert threshold: <30 days",
  "panelTypes": "graph",
  "queryData": [
    {
      "queryName": "A",
      "promQL": "certmanager_certificate_expiration_timestamp_seconds - time()",
      "legend": "{{namespace}}/{{name}}"
    }
  ]
}

Multiply this by 90 panels, organize into logical sections, and you have a complete dashboard. My cert-manager PR was 12,900 lines — sounds massive, but it's structured JSON that follows a pattern.

Step 5: Validate Before Submitting

This is where most bounty submissions fail. I validate every dashboard by:

1. Schema validation — does the JSON parse correctly?
2. Query validation — do the PromQL/SQL queries reference real metrics?
3. Layout check — are panels organized logically for an operator's workflow?
4. Documentation — does the PR describe what's monitored and why?

My Results So Far

Total pipeline: $750 from 4 PRs in 3 days.

The key insight: this is repeatable. SigNoz has dozens of dashboard requests open. Other monitoring platforms have similar programs.

Tools That Speed This Up

The repetitive nature of dashboard JSON makes this perfect for AI-assisted development:

• Dashboard Builder Skill — generates SigNoz/Grafana-compatible JSON from a metrics spec. I describe what I want to monitor, it produces the panel structure. Saved me hours on the 90-panel cert-manager dashboard.
• API Connector Skill — when the dashboard needs to pull from non-standard APIs, this handles the integration boilerplate.

How to Find More Dashboard Bounties

1. GitHub search: label:bounty dashboard across monitoring tool repos
2. SigNoz issues: filter by bounty label, look for "dashboard template" requests
3. Grafana community: check their dashboard marketplace for gaps
4. Algora.io: aggregates bounties across repos — filter for "dashboard" or "monitoring"

The Math

If each dashboard takes 2-4 hours and pays $150-$250:

• Hourly rate: $37-$125/hr
• Weekly potential (10 hrs/week): $375-$625
• Monthly: $1,500-$2,500

Compare that to the median Algora bounty ($100-$300 for complex code changes that take 8-20 hours). Dashboard bounties have a better effort-to-payout ratio.

Common Mistakes to Avoid

1. Submitting before the dashboard is complete — partial submissions get rejected
2. Ignoring the target platform's conventions — SigNoz dashboards use a specific JSON schema. Don't submit Grafana format to a SigNoz issue.
3. No documentation — explain what each section monitors and why an operator would care
4. Racing to submit first — quality matters more than speed. Multiple contributors get rewarded on the same issue.

Start Here

Pick one monitoring platform. Learn its dashboard JSON format. Find an open bounty issue. Build one dashboard end-to-end.

Once you've done one, the second takes half the time. By the fourth, you have a repeatable system.

The boring work that nobody wants to do is often the most profitable.