Trust Score Analysis

What is Trust Score Analysis?

Trust Score Analysis is an automated system that helps recruiters evaluate the authenticity and quality of developer profiles. Instead of manually reviewing hundreds of GitHub repos, LeetCode problems, and LinkedIn claims, recruiters get a single trust score (0-100) with detailed breakdowns.

> For Candidates: This documentation explains how YOUR profile is evaluated by recruiters using Profile Analyzer. Understanding this helps you maintain a strong, authentic presence across platforms.

> For Recruiters: Learn how the trust scoring works, what it measures, and how to use it as a decision-support tool in your hiring process.

Why Trust Scoring Exists

The Problem:

• Candidates inflate skills on LinkedIn
• GitHub profiles contain template repos and low-effort commits
• LeetCode activity spikes suspiciously before interviews
• Traditional resume screening misses these red flags

The Solution: Trust Score Analysis automatically detects patterns that indicate:

• ✅ Authentic technical work vs. ⚠️ Profile padding
• ✅ Consistent learning vs. ⚠️ Last-minute cramming
• ✅ Real expertise vs. ⚠️ Claimed skills without evidence

How Trust Scores Are Calculated

Trust scores are calculated using 5 independent analyzers, each examining a different aspect of your profile:

1. LinkedIn Profile Analysis (Base Weight: 15%)

What it checks:

• Title-Complexity Match: Does your job title align with observable work?
• Skills Evidence: For each claimed skill, is there GitHub/LeetCode proof?
• Experience Verification: Does your claimed experience match GitHub account age and contribution depth?

Example Red Flag:

• Claims 8 years of Python experience
• GitHub account is 2 years old
• No Python repos with substantial commits
• Result: Low LinkedIn score

Privacy Note: Only YOUR connected LinkedIn data is analyzed. No data is shared externally.

2. GitHub Repository Quality (Base Weight: 35%)

What it checks:

• Quality Repos: How many repos have good commit patterns, documentation, and tests?
• Commit Granularity: Are commits small and frequent (good) or massive single commits (red flag)?
• Test Coverage Score: Do repos include tests?
• Template Detection: Are repos just starter templates/boilerplate?
• Low-Effort Indicators: Single-commit repos, fork-only profiles, or repos with minimal code

Example Red Flag:

• 50 GitHub repos total
• 45 are forks with 0 commits
• 5 are single-commit template projects
• Result: Low GitHub Quality score

What Counts as "Quality":

• Regular commit history (not bulk commits)
• Meaningful code changes (not just README updates)
• Original work (not template clones)
• Evidence of testing and documentation

3. LeetCode Problem Solving (Base Weight: 25%)

What it checks:

• Difficulty Distribution: Balanced mix of Easy, Medium, Hard problems
• Acceptance Rate: High acceptance means thoughtful solutions (not brute force)
• Contest Performance: Participation and ranking in coding contests
• Activity Consistency: Regular practice vs. sudden spikes

Example Red Flag:

• 200 Easy problems, 5 Medium, 0 Hard
• Acceptance rate: 35% (below average)
• No contest participation
• Result: Low LeetCode score

Ideal Profile:

• ~30% Easy, ~50% Medium, ~20% Hard
• Acceptance rate >60%
• Recent consistent activity (not 6-month gaps)

4. Codeforces Competitive Programming (Base Weight: 15%)

What it checks:

• Current & Max Rating: Competitive skill level
• Contest Participation: Active competition frequency
• Problem Diversity: Breadth across difficulty levels
• Rating Stability: Genuine progress vs. manipulation

Example Red Flag:

• Max rating: 2100, Current rating: 1200
• Large rating drop suggests manipulation or inactivity
• Result: Lower Codeforces score

Ideal Profile:

• Consistent rating growth
• Regular contest participation
• Diverse problem-solving

Note: Codeforces is optional. If not connected, weight redistributes to other platforms.

5. Activity Pattern Consistency (Base Weight: 10%)

What it checks (Cross-Platform Behavioral Analysis):

• GitHub Activity Spikes: Sudden burst of commits before job applications
• Long Inactivity Periods: 6+ month gaps in coding activity
• LeetCode Hiring Window Activity: Suspicious concentration around interview seasons
• Difficulty Jumps: Sudden jump from Easy to Hard without gradual progress

Example Red Flag:

• 0 GitHub commits for 8 months
• 150 LeetCode problems solved in 14 days before applying
• All activity timestamps between 2-5 AM (unusual pattern)
• Result: Low Activity Consistency score

What's Normal:

• Gradual skill progression
• Consistent activity across months (not just pre-interview)
• Cross-platform engagement (not just one platform)

Dynamic Weight Redistribution

Base weights assume all platforms are connected:

• LinkedIn: 15%
• GitHub: 35%
• LeetCode: 25%
• Codeforces: 15%
• Activity Pattern: 10%

If platforms are missing, weights adjust automatically:

| Platforms Connected | Actual Weights | ||-| | All 5 platforms | Base weights | | GitHub + LeetCode only | GitHub: 58%, LeetCode: 42% | | GitHub only | GitHub: 100% |

This means: You won't be penalized for not having Codeforces or LeetCode—weights simply shift to available data.

Understanding Your Trust Score

Score Ranges & Confidence Bands

| Score | Confidence Band | Meaning | |-|-|| | 80-100 | High Confidence | Strong, authentic profile with quality work | | 60-79 | Moderate Confidence | Generally solid, minor inconsistencies | | 40-59 | Low Confidence | Several red flags detected | | 0-39 | Requires Careful Review | Significant authenticity concerns |

Score Breakdown

Trust scores show: 1. Overall Score (0-100) 2. Individual Platform Scores (each 0-100) 3. Applied Weights (dynamic based on availability) 4. Detailed Analysis for each platform

Example:

Overall Trust Score: 75 Confidence Band: Moderate Confidence

Signal Breakdown:

• LinkedIn Profile: 80/100 (15% weight)
• GitHub Quality: 85/100 (35% weight)
• LeetCode: 70/100 (25% weight)
• Codeforces: N/A (not connected)
• Activity Consistency: 65/100 (25% weight - redistributed)

For Candidates: How to Improve Your Trust Score

✅ DO:

• Build consistently: Regular commits > massive one-time pushes
• Show real work: Original projects > forked templates
• Document progress: READMEs, tests, meaningful commit messages
• Practice genuinely: Gradual difficulty progression on LeetCode
• Stay active: Regular activity across all connected platforms
• Be honest: Don't claim skills you can't demonstrate

❌ DON'T:

• Bulk upload old projects all at once before job hunting
• Fork 100 repos without contributing
• Claim 10+ years experience with 1-year GitHub history
• Solve 200 Easy problems and claim you're "expert level"
• Go inactive for months, then "cram" right before applying
• Add skills to LinkedIn that have zero GitHub evidence

Quick Wins:

1. Add tests to your repos → Boosts GitHub Quality score 2. Write better commit messages → Shows thoughtful development 3. Solve Medium/Hard problems → Improves LeetCode distribution score 4. Update LinkedIn skills to match GitHub → Better alignment score 5. Maintain 2-3 active projects → Better than 50 abandoned repos

For Recruiters: How to Use Trust Scores

As Decision-Support, Not Final Judgment

❌ Wrong: "Trust score is 45, reject candidate immediately." ✅ Right: "Trust score is 45, let's review the red flags during interview."

Trust scores are screening tools, not replacements for technical interviews.

What to Do with Each Score Range:

High Confidence (80-100):

• Profile is likely authentic
• Proceed with standard interview process
• Ask about specific projects/problems in interviews

Moderate Confidence (60-79):

• Profile is generally solid
• Review the specific red flags (click "Details" in Trust Score Card)
• Ask clarifying questions during interview

Low Confidence (40-59):

• Multiple red flags detected
• Review detailed breakdown before proceeding
• Focus interview heavily on technical depth

Requires Careful Review (0-39):

• Significant authenticity concerns
• Review all platform details
• Consider technical screening before interview
• Ask behavioral questions about consistency gaps

Viewing Trust Score Details

1. Go to candidate profile in dashboard 2. Scroll to Trust Analysis card 3. Click "Recalculate" for latest data 4. Click "Details" on each platform signal to see: - Specific repos flagged as low-effort - Skills claimed vs. evidence found - Activity spike dates and patterns - Test coverage metrics

Privacy & Data Protection

What Data is Analyzed?

✅ Only data YOU connected:

• Public GitHub repos (not private repos)
• LeetCode stats (if you connected it)
• Codeforces stats (if you connected it)
• LinkedIn profile (if you connected it)

❌ Never accessed:

• Private repositories
• Direct messages
• Personal emails
• NDA-protected work

Who Can See Your Trust Score?

• Recruiters: Only recruiters using Profile Analyzer can see trust scores
• Other Candidates: Cannot see your trust score
• Public: Trust scores are NEVER public (even on your public profile page)

Data Sharing

🔒 Zero External Sharing:

• Trust score calculations happen on Profile Analyzer servers
• No data is sent to third parties
• Your GitHub/LeetCode/Codeforces data stays within this platform
• Recruiters see aggregated scores, not raw API data

Limitations & Disclaimers

What Trust Scores Cannot Detect:

❌ Private Contributions: Company work in private repos is invisible ❌ NDA Work: Contract work under non-disclosure agreements ❌ Offline Learning: Books, courses, in-person mentorship ❌ Soft Skills: Communication, teamwork, leadership ❌ Domain Expertise: Industry-specific knowledge ❌ Cultural Fit: Values alignment with company

Use as Decision-Support Only

> ⚠️ Important: This analysis cannot account for private repositories, NDA-restricted work, or contributions not visible on public platforms. Use as decision-support during interviews, not as a sole hiring criterion.

Trust scores complement traditional interviews, not replace them.

Frequently Asked Questions

For Candidates:

Q: Will a low trust score hurt my job prospects? A: Not directly. Recruiters use it as a screening tool, but your interview performance matters most. Use the breakdown to improve your profile.

Q: Can I see my own trust score? A: Currently, trust scores are only visible to recruiters. We're considering adding a "preview mode" for candidates.

Q: Why is my score low even though I'm a good developer? A: Trust scores measure profile authenticity, not skill. If you have private repos, NDA work, or inconsistent public activity, scores may not reflect your true ability.

Q: Can I dispute my trust score? A: Scores are calculated automatically. Instead of disputing, focus on improving the specific red flags shown in the breakdown.

Q: Does this system replace technical interviews? A: No. It's a pre-screening tool. Interviews assess depth, problem-solving, and communication—things trust scores cannot measure.

For Recruiters:

Q: How often should I recalculate trust scores? A: Recalculate before each interview round to get fresh data (candidates may have updated profiles).

Q: What if a candidate has a low score but great interview performance? A: Trust the interview! Trust scores are screening tools, not final verdicts. Humans always have final say.

Q: Can candidates game the system? A: Possibly, but it's difficult. Gaming requires months of consistent, quality work—which is essentially what we want candidates to do anyway.

Q: Should I tell candidates about their trust score? A: Not recommended. It may cause anxiety or defensive behavior. Use it internally for screening prioritization.

Q: What about senior developers with old GitHub accounts? A: Experience verification accounts for this. Older accounts with deep contribution history score well.

Try It Out

Recruiters: View Candidate Trust Scores →

Candidates: Improve Your Public Profile →

Technical Details (For Developers)

Calculation Version

Current system: v2.0.0 (Platform-Agnostic Architecture)

API Endpoints

• GET /api/v1/recruiters/trust-score/:userId - Fetch trust score
• POST /api/v1/recruiters/recalculate-trust/:userId - Recalculate score

Response Structure

JSON response includes:

• overallTrustScore (0-100)
• confidenceBand ("High Confidence", "Moderate Confidence", "Low Confidence", "Requires Careful Review")
• signalBreakdown (individual platform scores)
• appliedWeights (dynamic weights used in calculation)

Platform Registry (Extensible)

Adding new platforms requires: 1. Create analyzer in services/trustDetection/ 2. Add to PLATFORM_REGISTRY 3. Update TrustScore schema 4. Frontend displays it automatically

Feedback & Improvements

Trust Score Analysis is continuously evolving. Have suggestions?

• Report issues via GitHub
• Contact support
• Share feedback in community forums

Last updated: January 2026 Version: 2.0.0 (Platform-Agnostic System)