Push GitHub Developer Leads to Productboard

Productboard is where product teams organize customer feedback and prioritize features. Most product teams feed Productboard from Intercom, Zendesk, and sales calls — but they miss the clearest signal of developer intent: what developers are actually doing on GitHub. This integration closes that gap.

What GitHub Signals Tell Productboard

When a developer stars your competitor's repo, opens an issue mentioning a specific pain point, or commits code that uses a keyword related to your product category, that is structured market intelligence. Pushing those signals into Productboard as notes or feature feedback gives your product team a real-time view of what developers actually want — not what they say in surveys.

• Stargazers of competitor repos signal that developers are actively evaluating alternatives to your product
• GitHub issues mentioning specific keywords reveal pain points and unmet needs in your market
• Code commits using specific APIs show which integrations and use cases are most common
• Stars on your own repo (or similar tools) signal that a developer has found your product category and is evaluating options

Integration Architecture

GitLeads captures the GitHub signal and enriches it with the developer's profile. You then route that enriched record to Productboard via webhook, Zapier, or direct API call. The two most useful destinations in Productboard are Notes (raw customer feedback) and Insights (processed feedback linked to features).

// GitLeads webhook → Productboard Notes API
import Fastify from 'fastify';

const app = Fastify();

interface GitLeadsSignal {
  github_username: string;
  email?: string;
  full_name?: string;
  company?: string;
  signal_type: 'stargazer' | 'keyword';
  signal_context: string;
  repo?: string;
  keyword?: string;
}

app.post('/webhook/gitlabels-to-productboard', async (req, reply) => {
  const signal = req.body as GitLeadsSignal;

  const noteContent = signal.signal_type === 'stargazer'
    ? `Developer @${signal.github_username} starred ${signal.repo}. Company: ${signal.company || 'unknown'}. This may indicate evaluation of this tool.`
    : `Developer @${signal.github_username} mentioned "${signal.keyword}" on GitHub. Context: ${signal.signal_context}`;

  const response = await fetch('https://api.productboard.com/notes', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.PRODUCTBOARD_TOKEN}`,
      'X-Version': '1',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      data: {
        title: `GitHub signal: ${signal.github_username}`,
        content: noteContent,
        source: {
          origin: 'github-gitlabels',
          record_id: signal.github_username,
        },
        customer_email: signal.email,
        tags: ['github-signal', signal.signal_type],
      },
    }),
  });

  reply.send({ ok: response.ok });
});

Setting Up the GitLeads → Productboard Pipeline

1. In GitLeads, create a stargazer signal on repos you want to monitor (competitors, your own repo, category leaders)
2. Create a keyword signal for terms that indicate buying intent in your product category
3. Configure a webhook destination in GitLeads pointing to your endpoint or use Zapier/n8n
4. In Productboard, create a Source for GitHub signals and note the API token
5. Map the GitLeads signal fields to Productboard Note fields: signal_context → content, github_username → customer record, company → company filter
6. Tag notes by signal type so product teams can filter: "stargazer-competitor", "keyword-pain-point"

Productboard API Note Creation

import httpx

PRODUCTBOARD_TOKEN = "your_token_here"

def push_to_productboard(signal: dict):
    content = (
        f"GitHub signal from @{signal['github_username']}\n\n"
        f"Signal type: {signal['signal_type']}\n"
        f"Context: {signal['signal_context']}\n"
        f"Company: {signal.get('company', 'Unknown')}\n"
        f"Location: {signal.get('location', 'Unknown')}\n"
        f"Top languages: {', '.join(signal.get('top_languages', []))}"
    )

    resp = httpx.post(
        "https://api.productboard.com/notes",
        headers={
            "Authorization": f"Bearer {PRODUCTBOARD_TOKEN}",
            "X-Version": "1",
        },
        json={
            "data": {
                "title": f"GitHub signal: {signal['signal_type']} from {signal['github_username']}",
                "content": content,
                "customer_email": signal.get("email"),
                "source": {
                    "origin": "github",
                    "record_id": signal["github_username"],
                },
            }
        },
    )
    return resp.json()

Filtering Signals Worth Sending to Productboard

Not every GitHub signal is worth creating a Productboard note. Filter for quality before pushing. Prioritize signals from developers with 100+ followers (senior engineers), developers at companies with 50+ employees (enterprise buyers), and keyword signals that mention specific pain points rather than just API usage.