Clash of Techs - Benchmark Guide

Performance comparison tool for Frontend frameworks (React, Angular, Next.js, Svelte, Flutter) and Backend frameworks (NestJS, .NET Core, Go/Gin, FastAPI, Spring Boot).

Frontend Benchmarks

Frontend Frameworks

• React - Flexible component library
• Angular - Full-featured framework
• Next.js - React framework with SSR
• Svelte - Compiler-based framework
• Flutter - Cross-platform UI toolkit

Frontend Metrics

Lighthouse Metrics (Core Web Vitals)

Build & Runtime Metrics

Quick Start: Update Frontend Metrics

Use the Python script to automatically extract Lighthouse metrics:

# 1. Run Lighthouse on your app
lighthouse http://localhost:3000 --only-categories=performance --output=json --output-path=./report/react_report.json

# 2. Update the framework JSON with extracted metrics
python scripts/update-frontend.py react report/react_report.json

The script extracts these metrics from the Lighthouse report:

• FCP (First Contentful Paint)
• LCP (Largest Contentful Paint)
• TTI (Time to Interactive)
• TBT (Total Blocking Time)
• CLS (Cumulative Layout Shift)
• SI (Speed Index)

Measuring Frontend Metrics

Running Lighthouse

# Install Lighthouse CLI
npm install -g lighthouse

# Run Lighthouse and save JSON report
lighthouse http://localhost:3000 --only-categories=performance --output=json --output-path=./report/react_report.json

# Update metrics JSON
python scripts/update-frontend.py react report/react_report.json

Bundle Size

Production bundle size after tree-shaking and minification.

# React
npm run build && du -sh build/

# Angular
ng build --configuration=production && du -sh dist/

# Next.js
npm run build && du -sh .next/

# Svelte
npm run build && du -sh build/

# Flutter Web
flutter build web --release && du -sh build/web/

Build Time

# Use 'time' command to measure build duration
time npm run build

Memory Usage

# Chrome DevTools:
# 1. Open DevTools (F12)
# 2. Go to Memory tab
# 3. Take heap snapshot
# 4. Note "Total Size" in MB

Running Production Builds Locally

# React
npm run build && npx serve -s build

# Angular
ng build && npx serve dist/<project-name>/browser

# Next.js
npm run build && npm run start

# Svelte/SvelteKit
npm run build && npm run preview

# Flutter Web
flutter build web --release
python -m http.server 8080 --directory build/web
# or: npx serve build/web

Frontend JSON Structure

Save frontend benchmark results to compare/frontend/<framework>.json:

{
  "framework": "React",
  "version": "19.0.0",
  "measuredAt": "2026-01-28T23:07:05Z",
  "environment": {
    "node": "22.0.0",
    "browser": "Chrome 132",
    "os": "Windows 11"
  },
  "lighthouse": {
    "fcpMs": 2255,
    "lcpMs": 2405,
    "ttiMs": 2405,
    "tbtMs": 0,
    "cls": 0,
    "siMs": 2255
  },
  "build": {
    "bundleSizeKB": 287,
    "buildTimeSeconds": 8.6
  },
  "runtime": {
    "memoryUsageMB": 14.5
  }
}

File naming convention:

compare/frontend/
├── react.json
├── angular.json
├── nextjs.json
├── svelte.json
└── flutter.json

Update Script Usage

python scripts/update-frontend.py <framework> <lighthouse-report.json>

# Examples:
python scripts/update-frontend.py react report/react_report.json
python scripts/update-frontend.py angular report/angular_report.json
python scripts/update-frontend.py nextjs report/nextjs_report.json
python scripts/update-frontend.py svelte report/svelte_report.json
python scripts/update-frontend.py flutter report/flutter_report.json

The script will:

1. Read the Lighthouse JSON report
2. Extract all 6 Lighthouse metrics (FCP, LCP, TTI, TBT, CLS, SI)
3. Update or create the framework JSON file
4. Preserve existing build and runtime sections

Frontend Industry Reference Values

Lighthouse Metrics

Build & Runtime Metrics

Backend Benchmarks

Quick Start

# 1. Start any backend on port 8080
# 2. Run the benchmark with backend name
node benchmark.js gin        # Go/Gin
node benchmark.js fastapi    # Python/FastAPI
node benchmark.js nestjs     # NestJS
node benchmark.js netcore    # .NET Core
node benchmark.js springboot # Spring Boot

Results are saved to compare/<backend>.json

Automated Metrics

The benchmark script automatically measures:

Manual Metrics

These metrics need to be measured separately and updated in health/<backend>.json:

Cold Start Time

Time from process start to first request served.

Go (Gin)

# Terminal 1: Start with timing
time ./gin-app

# Terminal 2: Wait for "Listening on :8080" then immediately
curl http://localhost:8080/

Python (FastAPI)

# Use uvicorn startup time
time uvicorn main:app --host 0.0.0.0 --port 8080 &
# Wait for "Uvicorn running" message
curl http://localhost:8080/

.NET Core

# Measure startup
time dotnet run &
# Wait for "Now listening on" message
curl http://localhost:8080/

NestJS

# Measure startup
time npm run start:prod &
# Wait for "Nest application successfully started"
curl http://localhost:8080/

Spring Boot

# Measure startup (shown in console output)
mvn spring-boot:run
# Look for "Started Application in X.XXX seconds"

Bundle Size

Production build size including runtime dependencies.

Go (Gin)

# Build optimized binary (stripped)
go build -ldflags="-s -w" -o api ./cmd/api

# Check size
du -h api

Typical size: ~10-15 MB (single binary, no dependencies)

Python (FastAPI)

# Build Docker image
docker build -t python-todo-api .

# Check image size
docker images python-todo-api

Typical size: ~40-60 MB (with uvicorn, pydantic, etc.)

.NET Core

# Publish to ./publish folder
dotnet publish -c Release -o ./publish

# Check size
du -sh ./publish

Typical size: ~80-100 MB (self-contained) or ~5-10 MB (framework-dependent)

NestJS

# Get node_modules size (production dependencies only)
npx cost-of-modules --no-install --production

# Build production and check dist folder size
npm run build
du -sh dist/

Total bundle size: node_modules size + dist folder size

Typical size: ~80-100 MB (mostly node_modules)

Spring Boot

# Build fat JAR with Gradle
./gradlew bootJar

# Check JAR size
ls -lh build/libs/*.jar

Typical size: ~100-150 MB (fat JAR with embedded Tomcat)

Build Time

Time to create a production/release build.

Go (Gin)

time go build -o app

Typical time: ~2-5 seconds

Python (FastAPI)

# No build step required (interpreted)
# If using Docker:
time docker build -t fastapi-app .

Typical time: ~0 seconds (no compilation) or ~30-60s for Docker

.NET Core

time dotnet publish -c Release

Typical time: ~8-15 seconds

NestJS

time npm run build

Typical time: ~5-10 seconds

Spring Boot

time mvn clean package -DskipTests
# or with Gradle
time ./gradlew build

Typical time: ~30-60 seconds

Industry Standard Values

Reference values based on typical production environments:

Updating Health Files

After measuring cold start and bundle size, update the compareData section in each health file:

// health/dotnet.json
{
  "compareData": {
    "memoryUsageMB": 95,
    "coldStartMs": 420, // ← Update this
    "bundleSizeMB": 95, // ← Update this
    "responseTimeMs": 1.5,
    "requestsPerSec": 38000,
    "concurrentConnections": 22000
  }
}

Running Benchmarks for All Backends

# 1. Start Go backend
cd go-backend && ./app &
node benchmark.js
pkill app

# 2. Start Python backend
cd python-backend && uvicorn main:app --port 8080 &
node benchmark.js
pkill uvicorn

# 3. Start .NET backend
cd dotnet-backend && dotnet run &
node benchmark.js
# Ctrl+C to stop

# 4. Start NestJS backend
cd nestjs-backend && npm run start:prod &
node benchmark.js
pkill node

# 5. Start Spring backend
cd spring-backend && mvn spring-boot:run &
node benchmark.js
# Ctrl+C to stop

Static Metrics Collection

Collect static metrics (dependencies, build size, LOC) without running the server:

┌─────────────┬──────────────┬────────────┬───────────────┐
│ Backend     │ Dependencies │ Build Size │ Lines of Code │
├─────────────┼──────────────┼────────────┼───────────────┤
│ .NET Core   │ 7            │ 51.01 MB   │ 1,287         │
│ Spring Boot │ 13           │ 44.7 MB    │ 604           │
│ Go          │ 57           │ 86.87 MB   │ 2,089         │
│ NestJS      │ 39           │ 0.31 MB    │ 697           │
│ FastAPI     │ 19           │ N/A        │ 1,222         │
└─────────────┴──────────────┴────────────┴───────────────┘

Usage:

python collect-metrics.py gin        # Run for Go (Gin)
python collect-metrics.py fastapi    # Run for FastAPI
python collect-metrics.py nestjs     # Run for NestJS
python collect-metrics.py netcore    # Run for .NET Core
python collect-metrics.py springboot # Run for Spring Boot

The script:

1. Parses dependency files (.csproj, build.gradle.kts, go.mod, package.json, pyproject.toml)
2. Measures build output sizes
3. Counts lines of code (excluding test files, build artifacts)
4. Merges with existing compare JSON if present
5. Saves to compare/<backend>.json

Output Files

compare/
├── gin.json        # Go benchmark results
├── fastapi.json    # Python benchmark results
├── netcore.json    # .NET benchmark results
├── nestjs.json     # NestJS benchmark results
└── springboot.json # Spring benchmark results

Health Endpoint Requirements

Each backend must expose GET / returning:

{
  "status": "healthy",
  "version": "1.0.0",
  "environment": "development",
  "server": {
    "name": ".NET Core",
    "language": "C#",
    "frameworkVersion": ".NET 10.0"
  },
  "memory": {
    "rssMB": 72.5
  },
  "compareData": {
    "coldStartMs": 420,
    "bundleSizeMB": 95
  }
}

Tips

• Run benchmarks on the same machine for fair comparison
• Close other applications during benchmarking
• Run each benchmark 2-3 times and average the results
• Use production builds, not development mode
• Consider Docker containers for consistent environments