DevRank

Guides

Developer ranking system that measures influence and expertise within the developer community.

Overview

DevRank analyzes the follower graph to compute “Cracked Scores” - a metric that quantifies developer influence based on who follows them, how diverse their network is, and how they connect across communities.

Unlike simple follower counts, DevRank considers:

Network Quality - Following influential developers matters more than follower count
Independence - Cross-community connections show breadth of influence
Reciprocity - One-directional follows (where someone follows you but you don’t follow them) carry more weight
Participation - Connecting across diverse communities rather than staying in echo chambers

Understanding DevRank Data

Every user with DevRank data has the following metrics:

Cracked Score

The main ranking metric, normalized to a bell curve distribution.

Range: 0-100
Mean: 50
Standard Deviation: 15
Interpretation: Higher scores indicate greater influence in the developer community

Example Values:

42.5 = Intermediate (average developer)
63.2 = Advanced (top ~20%)
74.7 = Expert (top ~5%)
83.6 = Expert/Elite boundary (top ~1%)

Tier Assignment

Developers are grouped into five tiers based on their Cracked Score:

Tier	Description	Score Range	Percentile
Elite	Top 1% of developers	~84+	Top 1%
Expert	Highly influential developers	~74-84	Top 5%
Advanced	Strong community presence	~63-74	Top 20%
Intermediate	Active community members	~42-63	Middle 60%
Developing	Growing developer presence	<42	Bottom 20%

Trust Score

The underlying PageRank score before normalization.

What it measures: Raw influence propagation through the follower graph
Range: 0 to ~1 (but typically very small numbers like 8.27e-8)
Higher = More influential: Users with higher trust scores have followers who themselves are influential

Example Values:

8.27e-8  = Baseline (minimal network effect)
8.80e-8  = Slight boost from quality followers
1.50e-7  = Notable influence
2.26e-7  = Strong influence (Expert tier)

Participation Coefficient (pc)

Measures how diverse your network is across different communities.

Range: 0 to 1
0: All connections within a single community (echo chamber)
1: Maximum diversity across many communities
Interpretation: Higher values indicate broader influence

Example Values:

0.0      = Siloed in one community
0.45     = Moderate cross-community connections
0.66     = Strong diversity (Advanced tier)
0.72     = Excellent diversity (Expert tier)

Network Metrics

Followers In (followers_in):

Number of users following you
Measures direct reach

Following Out (following_out):

Number of users you follow
Context for reciprocity analysis

Community (community):

Identifier for your primary community cluster
Communities are detected using graph algorithms
Same number = developers in similar networks

Timestamps

Created At: When DevRank was first calculated for this user Updated At: When DevRank was last recalculated (typically daily/weekly)

How DevRank is Calculated

DevRank uses GPU-accelerated graph algorithms to analyze the entire follower network:

1. Graph Construction

The follower graph is built from follow relationships, creating a directed graph where edges represent “X follows Y”.

2. Community Detection

Communities are discovered using modularity optimization - clusters of developers who tend to follow each other more than outsiders.

3. Edge Weighting

Each follow relationship is weighted based on:

Surprise: Following unexpectedly popular users = higher weight
Reciprocity: Mutual follows = penalized (0.7x weight)
Independence: Cross-community follows = boosted (1.2x weight)

4. Trust Propagation

Weighted PageRank algorithm computes how influence flows through the network. If influential developers follow you, your trust score increases.

5. Participation Coefficient

Measures connection diversity:

pc = 1 - Σ(connections_in_community_i / total_connections)²

6. Score Normalization

Raw scores are transformed to a bell curve (mean=50, std=15) to make comparisons intuitive.

7. Tier Assignment

Final tiers are assigned based on score percentiles.

Example Data

Here are sample DevRank records showing the range of scores:

User ID	Cracked Score	Tier	Trust	PC	Followers	Following	Community
`00001f5f27...`	81.28	Expert	6.88e-7	0.72	106	207	4
`000022c1e8...`	74.68	Expert	3.54e-7	0.00	1	0	1
`00001b6eeb...`	63.68	Advanced	1.31e-7	0.49	3	0	0
`0000391ae4...`	69.87	Advanced	2.17e-7	0.55	28	6	2
`000015c3ca...`	42.55	Intermediate	0	0.00	0	1	0
`000044eaf6...`	53.72	Intermediate	1.29e-8	0.00	1	0	9
`00003c6e94...`	33.10	Developing	0	0.00	0	5	2
`0000209a17...`	49.88	Intermediate	6.66e-9	0.00	1	1	55

Observations:

High scores don’t always mean high follower counts (quality > quantity)
Cross-community influence (high PC) boosts scores
Elite/Expert developers often have balanced follow ratios
Community diversity matters as much as network size

Using DevRank via API

DevRank data can be included in user responses via the includeAttributes parameter:

// Get users with DevRank data
const result = await client.raw.getUsersByGithubIds({
  githubIds: ["MDQ6VXNlcjU4MzIzMQ=="],
  includeAttributes: {
    devrank: true,
  },
});

// Access DevRank fields
const user = result.users[0];
if (user.devrank) {
  console.log(`Tier: ${user.devrank.tier}`);
  console.log(`Score: ${user.devrank.crackedScore}`);
  console.log(`Trust: ${user.devrank.trust}`);
  console.log(`Participation: ${user.devrank.pc}`);
}

Interpreting DevRank

High Cracked Score (70+)

What it means:

Influential in the developer community
Followed by other influential developers
Likely a maintainer, educator, or recognized expert

Use cases:

Finding thought leaders
Identifying potential speakers/mentors
Discovering quality open source contributors

High Participation Coefficient (0.5+)

What it means:

Connects across multiple communities
Broad expertise or interests
Bridge between different tech ecosystems

Use cases:

Finding polyglot developers
Identifying cross-functional engineers
Discovering developers with diverse experience

High Follower Imbalance (Following « Followers)

What it means:

Others seek their content/expertise
Less reciprocal following
Strong personal brand

Use cases:

Finding content creators
Identifying influencers
Discovering educators

Community Clustering

What it means:

Developers with the same community ID have similar networks
Communities often align with tech stacks, companies, or interests

Use cases:

Finding developers in similar ecosystems
Identifying niche communities
Mapping tech community structure

Caveats & Limitations

Not a Quality Metric

DevRank measures influence, not skill. A high score means:

Many people find you worth following
You’re connected to influential developers
Your network is diverse

It does NOT mean:

Better code quality
More experience
Greater technical ability

Recency

DevRank is recalculated periodically (typically weekly). Recent changes in follower networks may not be reflected immediately.

Coverage

DevRank is only available for users in our database who have been crawled and have follower data. Not all users have DevRank scores yet.

Privacy

DevRank is computed from public follower data only. No private information is used.

Credits

DevRank queries cost 1 credit per user when included via includeAttributes.

Leaderboard queries cost 2 credits per user (1 for user data + 1 for DevRank).

Next Steps

API Reference - Learn about DevRank API endpoints
Authentication Guide - Get your API key
Search Guide - Combine DevRank with search filters