GitHub Profile Analyzer

Professional Developer Intelligence Platform
Turn any public GitHub profile into actionable portfolio insights, career recommendations, and recruiter-ready reports.

Overview

GitHub Profile Analyzer is a production-ready web application that analyzes public GitHub profiles to generate deep insights, analytics, and career recommendations. Built for recruiters, hiring managers, developers, and open-source contributors, it transforms raw GitHub data into a premium, easy-to-read intelligence dashboard.

Whether you want to evaluate a candidate's portfolio, understand your own developer footprint, or identify skill gaps and growth opportunities, this tool delivers professional-grade analysis in seconds.

Key Features

Developer Intelligence

Profile Overview: Followers, following, public repositories, account age, and bio analysis.
Language Intelligence: Detects primary, secondary, and niche languages with visual distribution charts.
Tech Stack Classification: Automatically categorizes repositories into Frontend, Backend, DevOps, AI/ML, Mobile, and Data Science.
Contribution Analysis: Aggregates repository activity, stars, forks, and open issues to gauge engagement.

Scoring & Career Engine

0-100 Portfolio Score: Based on project diversity, documentation quality, and community engagement.
Coding Score: Evaluates code consistency, language breadth, and repository maturity.
Project Quality Score: Measures README quality, licensing, testing signals, and maintainability.
Career Role Recommendations: Suggests roles aligned with the developer's stack and contribution patterns.
Skill Gap Analysis: Identifies missing technologies and in-demand skills to learn next.
Project Recommendations: Recommends 3-6 project ideas tailored to the user's profile.
Personalized Roadmap: Generates 3, 6, and 12-month career growth plans.
Roast Mode: A humorous, honest critique of the profile's weaknesses.
Recruiter View: A concise summary optimized for hiring decision-makers.

Reporting & Exports

PDF Report: Professional, branded resume-style report with charts and recommendations.
JSON Export: Machine-readable structured data for integrations.
CSV Export: Tabular data for spreadsheet analysis.
Search History: Session-based recent searches for quick re-analysis.

Premium UI/UX

Dark SaaS Dashboard: Modern glassmorphism-inspired design with Tailwind CSS.
Interactive Charts: Doughnut charts for language distribution and bar charts for contribution activity.
Responsive Layout: Works on desktops, tablets, and mobile devices.
Loading States: Smooth skeleton loaders and animated feedback during analysis.

Live Demo

Local demo: Run the app and visit http://localhost:5000 after following the Installation steps.

Architecture

┌─────────────────────────────────────────────────────────────┐
│                        User Browser                          │
│              (Tailwind CSS + Chart.js UI)                   │
└───────────────────────┬─────────────────────────────────────┘
                        │ HTTP / Form + AJAX
┌───────────────────────▼─────────────────────────────────────┐
│                     Flask Application                       │
│  ┌──────────────┐ ┌──────────────┐ ┌──────────────┐        │
│  │   Routes     │ │   Services   │ │   Reports    │        │
│  │  (Blueprints)│ │  (Analysis)  │ │  (PDF/CSV)   │        │
│  └──────────────┘ └──────────────┘ └──────────────┘        │
└───────────────────────┬─────────────────────────────────────┘
                        │ REST API
┌───────────────────────▼─────────────────────────────────────┐
│                      GitHub API                             │
│              (Authenticated for higher rate limits)          │
└─────────────────────────────────────────────────────────────┘

The application follows a clean Service-Oriented Architecture inside Flask, separating routing, business logic, data access, and reporting concerns.

Tech Stack

Layer	Technology
Backend Framework	Flask 2.x / 3.x
HTTP Client	`requests`
Frontend Styling	Tailwind CSS 3.x
Charts & Visualizations	Chart.js 4.x
PDF Reports	`fpdf2`
CSV/JSON Exports	Built-in `csv`, `json`
Environment Management	`python-dotenv`
Session Storage	Flask `session`
Language Detection	GitHub API + custom repository heuristics

Project Structure

github_analyzer/
├── app/
│   ├── __init__.py              # Flask factory application
│   ├── config.py                # Configuration classes
│   ├── routes/
│   │   ├── __init__.py
│   │   ├── main.py              # Main dashboard and analysis routes
│   │   └── api.py               # Export and API endpoints
│   ├── services/
│   │   ├── github_client.py     # GitHub REST API client
│   │   ├── analyzer.py          # Profile aggregation & tech stack detection
│   │   ├── scorer.py            # 0-100 scoring algorithms
│   │   ├── recommender.py       # Career & project recommendations
│   │   └── report.py            # PDF report generation
│   ├── static/
│   │   ├── css/                 # Tailwind-inspired custom styles
│   │   └── js/                  # Chart.js initialization and interactions
│   └── templates/
│       ├── base.html            # Shared layout
│       ├── index.html           # Search / landing page
│       ├── dashboard.html       # Results dashboard
│       └── report.html          # Printable report preview
├── .env.example                 # Environment variable template
├── .gitignore
├── README.md                    # You are here
├── requirements.txt             # Python dependencies
└── run.py                       # Application entry point

Installation

Prerequisites

Python 3.10+
pip or virtualenv
GitHub Personal Access Token (recommended for higher rate limits)

Step-by-Step

Clone or extract the project

cd github_analyzer

Create a virtual environment

python -m venv venv

# On Windows
venv\Scripts\activate

# On macOS/Linux
source venv/bin/activate

Install dependencies

pip install -r requirements.txt

Configure environment variables

cp .env.example .env

Edit .env and add your GitHub token:

GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxx
SECRET_KEY=your-super-secret-key
FLASK_ENV=development
FLASK_APP=run.py

Run the application

python run.py

Open in browser

http://localhost:5000

Configuration

Variable	Required	Description
`GITHUB_TOKEN`	Recommended	GitHub Personal Access Token. Unauthenticated requests are limited to 60/hour; authenticated requests get 5,000/hour.
`SECRET_KEY`	Yes	Flask secret key for session encryption.
`FLASK_ENV`	Optional	`development` or `production`.
`FLASK_APP`	Optional	Entry point, typically `run.py`.

Creating a GitHub Token

Go to GitHub Settings → Developer Settings → Personal Access Tokens.
Click Generate new token (classic).
Select the public_repo and read:user scopes.
Copy the token and paste it into your .env file.

Usage

Open the app at http://localhost:5000.
Enter any public GitHub username (e.g., torvalds, gaearon, sindresorhus).
Click Analyze Profile.
Explore the dashboard:
- Overview cards
- Language distribution chart
- Contribution activity chart
- Tech stack breakdown
- Scores and analysis
- Career recommendations and roadmap
Download a PDF report, JSON data, or CSV export from the dashboard.

API Reference

Analyze Profile

POST /analyze
Content-Type: application/x-www-form-urlencoded

username=<github_username>

Redirects to the dashboard with the analysis results.

Export JSON

GET /export/json?username=<github_username>

Returns a JSON file with the full analysis payload.

Export CSV

GET /export/csv?username=<github_username>

Returns a CSV file with repository and scoring data.

Download PDF Report

GET /report/pdf?username=<github_username>

Returns a generated PDF report.

Scoring Methodology

Scores are calculated on a 0-100 scale across three dimensions:

Portfolio Score

Repository diversity (30%)
README and documentation quality (25%)
Community engagement: stars, forks, watchers (25%)
Profile completeness and bio quality (20%)

Coding Score

Number of languages used (30%)
Code consistency and commit frequency (25%)
Repository maturity and age (25%)
Open source activity (20%)

Project Quality Score

Presence of README files (30%)
License files (20%)
Testing signals (e.g., test, tests directories) (20%)
Issue and PR activity (15%)
Recent maintenance (15%)

Note: These scores are heuristic estimates based on public metadata. They are designed to assist, not replace, human evaluation.

Export Formats

Format	Description	Use Case
PDF	Branded, printable report with charts and recommendations	Recruiters, interviews, portfolio reviews
JSON	Structured full analysis payload	API integrations, data pipelines
CSV	Tabular repository and score data	Spreadsheet analysis, ATS imports

Deployment

Deploy to Render / Railway / Heroku

Push the project to a Git repository.
Set environment variables in the platform dashboard.
Use gunicorn as the production server:

pip install gunicorn
gunicorn -w 4 -b 0.0.0.0:5000 "app:create_app()"

Docker Deployment (Optional)

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 5000

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "app:create_app()"]

Build and run:

docker build -t github-analyzer .
docker run -p 5000:5000 --env-file .env github-analyzer

Performance & Rate Limits

Unauthenticated GitHub API: 60 requests/hour.
Authenticated GitHub API: 5,000 requests/hour.
Large profiles with 100+ repositories may require multiple API calls. Set GITHUB_TOKEN to avoid hitting limits.
Repository analysis is cached for the duration of the session via search history.

Contributing

Contributions are welcome! To contribute:

Fork the repository.
Create a feature branch: git checkout -b feature/your-feature.
Commit your changes: git commit -m "Add your feature".
Push to the branch: git push origin feature/your-feature.
Open a Pull Request.

Ideas for Contributions

Add support for GitHub Organizations.
Implement caching with Redis.
Add more advanced scoring models.
Integrate LinkedIn or LeetCode profiles.
Add multi-language support for the UI.

License

This project is licensed under the MIT License. See the LICENSE file for details.

Acknowledgments

Built with Flask
Styled with Tailwind CSS
Charts powered by Chart.js
Data provided by the GitHub API
PDF reports generated with fpdf2

Built with ❤️ for developers, recruiters, and open-source enthusiasts.

Name		Name	Last commit message	Last commit date
Latest commit History 3 Commits
github_analyzer		github_analyzer
LICENSE		LICENSE
README.md		README.md

Folders and files

Latest commit

History

Repository files navigation