Most developer portfolios are a list of projects and a few adjectives. I wanted one that shows how someone actually develops, from data that's hard to fake. DevInsight imports your GitHub repositories, measures activity, commit habits, structure and quality, turns that into scores you can trace back to the numbers, and publishes the result as a portfolio that keeps updating.

It started life as a Java/Spring Boot skeleton and I rewrote it on .NET 10 and Angular. Not deployed yet: the GitHub Pages + Azure Container Apps pipeline is in place (deploy-pages, deploy-api, infra) but skips until the Azure resources and DEVINSIGHT_API_URL are configured, so run it locally for now (see below).

Why a repository scored what it did	Public portfolio

The screenshots are from a local run against a made-up demo account (demo-dev) with generated repositories and commits, not real GitHub data. AI feedback was off, so all findings are the rule-based ones.

What you get:

• A private dashboard: scores, activity over time, score evolution, language mix, commit-size distribution, and the most important feedback across your repositories.
• Explainable scores. Every score is a weighted sum of stored metrics, and the UI shows each metric's value, points and weight. Two scopes: the whole repository, or only your own contributions.
• Feedback: rule-based findings (vague commits, monoliths, missing tests, ...) including what you do well, plus optional AI feedback grounded strictly in the measured data. Yes, it judges your commit messages.
• A public portfolio at /u/<github-login>: your selected repositories scored on your own commits, projects with images, languages, activity and strengths. Private until you publish it.

frontend/   Angular 22 SPA (standalone components, signals, zoneless, Vitest)
backend/
  src/
    DevInsight.Domain          entities, analysis engine, scoring, feedback rules (no dependencies)
    DevInsight.Application     use cases (UC1-UC6) and the ports they need
    DevInsight.Infrastructure  adapters: PostgreSQL (EF Core), GitHub (Octokit), git CLI, Claude, workers
    DevInsight.Api             ASP.NET Core minimal APIs, auth, OpenAPI, hosts the SPA
  tests/                       domain · application · infrastructure · architecture · API integration
docs/       API.md · DEPLOYMENT.md · DECISIONS.md (every design decision and why)
infra/      Bicep template for Azure Container Apps (+ PostgreSQL)

Hexagonal (ports & adapters): dependencies point inward, and an architecture test fails the build if the domain or application layer ever references EF Core, ASP.NET Core, Octokit or the AI SDK.

How an analysis runs: POST /api/analysis/run/{repo} stores a queued run and returns 202. A background worker clones the repository with git (one clone replaces thousands of rate-limited API calls), feeds the commit history and files at HEAD to the pure analysis engine, applies the feedback rules (and optionally Claude), and stores an append-only analysis. The sequence of analyses is the score history; a scheduled job re-analyses selected repositories daily so the history grows by itself.

Exact formulas and thresholds: docs/DECISIONS.md §26 and backend/src/DevInsight.Domain/Analyses/Engine.

.NET 10 (C# 14) · ASP.NET Core minimal APIs · EF Core 10 + PostgreSQL 17 · Octokit · Anthropic C# SDK · Azure Container Apps · Bicep · GitHub Actions (OIDC) · GitHub Pages · Angular 22 · ngx-charts · xUnit v3 · Shouldly · NetArchTest · Testcontainers · Vitest · Docker · mise.

Prerequisites: mise (installs the pinned .NET SDK and Node), Docker, and a GitHub OAuth App with callback URL http://localhost:4200/api/auth/github/callback.

mise install                                   # .NET 10.0.402 + Node 24.21.0
docker compose up -d db                        # PostgreSQL on :5432

cd backend
dotnet user-secrets --project src/DevInsight.Api set GitHub:ClientId     <client id>
dotnet user-secrets --project src/DevInsight.Api set GitHub:ClientSecret <client secret>
dotnet run --project src/DevInsight.Api        # API on :5080, migrates the database on startup

cd ../frontend
npm ci && npm start                            # SPA on :4200, proxies /api to :5080

Open http://localhost:4200, sign in with GitHub, import, analyse, publish.

Production (planned): the SPA targets GitHub Pages and the API Azure Container Apps. See docs/DEPLOYMENT.md and run bash scripts/setup-azure.sh once.

Everything in one container: cp .env.example .env, fill it in (callback URL http://localhost:8080/api/auth/github/callback), then docker compose up --build → http://localhost:8080.

AI feedback is optional: set AiFeedback:ApiKey (Anthropic API key) and every analysis gets up to five additional, data-grounded findings. Without it, feedback is rule-based only.

API reference: http://localhost:5080/scalar (OpenAPI at /openapi/v1.json); overview in docs/API.md.

cd backend && dotnet test          # all backend suites (API tests need Docker, or DEVINSIGHT_TEST_POSTGRES)
cd frontend && npm test            # Vitest with coverage

The API integration tests boot the real application (auth, database, background worker) against a disposable PostgreSQL and walk the whole journey (GitHub sign-in → import → analyse → dashboard → publish → public portfolio), plus the security cases (forged OAuth state, open redirects, cross-user access).

Implemented: UC1-UC6 from the specification, projects, scheduled snapshots, optional AI feedback. Next candidates: GitLab provider, historical score back-fill from commit history, recruiter view, CI coverage import. The original Spring Boot skeleton is still in the history (removed in 2423233) if you want to see where it started.