Executive & Technical Masterclass 01 / 20

ProGit: The Definitive Platform Educational Masterclass

A comprehensive engineering walkthrough of the zero-CGO sovereign Git platform: internals, deployment, administration, 24/7 operations, 18,000+ RPS performance, and 80% TCO savings.

1. Git Subsystem

Bare repository engine, pure-Go Smart HTTP, native SSH daemon, and safe process isolation.

Modules 02 - 04 Pure Go

2. Install & Deploy

Zero-config Web Wizard, single-command Podman/Docker containers, and auto-provisioned TLS.

Modules 05 - 07 Containerized

3. Admin & Ops

Global repo search, Git Management Dashboard, download restrictions, and SQLite WAL maintenance.

Modules 08 - 12 v1.7.0 Features

4. Speed & Cost ROI

Verified 18k+ RPS benchmarks, 45MB RAM peak footprint, and interactive 3-year TCO calculator.

Modules 16 - 19 80% Savings

Use ← and → or Space to navigate slides. Press O for the master index, F for fullscreen.

Module 01 • Git Subsystem 02 / 20

Direct Bare Repository Architecture

How ProGit interacts directly with Git bare repositories on disk without heavy virtualization layers or CGO bindings.

Pure-Go Architecture Principles

Zero CGO Dependencies: Compiled with CGO_ENABLED=0 into a single standalone static binary. No dynamic libc dependencies, preventing binary segfaults.

Direct Bare Storage: Stores repositories as standard Git bare trees at /data/repositories/{owner}/{repo}.git with separate .wiki.git stores.

Process Group Sandboxing: Spawns Git CLI subprocesses inside isolated process groups (proc_unix.go), guaranteeing complete child process cleanup upon request timeout.

# On-Disk Bare Git Storage Layout
/data/repositories/
└── perfadmin/
│ └── microservice-auth.git/
│ │ └── HEAD           # ref: refs/heads/main
│ │ └── config         # bare = true, gc.autoDetach=false
│ │ └── objects/       # Loose SHA-1 & packfiles
│ │ └── refs/          # branches, tags, heads
│ │ ┌── hooks/         # internal pre/post hooks
│ ┌── microservice-auth.wiki.git/ # Dedicated wiki store
┌── enterprise-org/
    ┌── core-platform.git/

30s / 120s Standard / Maintenance Git Subprocess Timeouts

0 CGO Zero external C libraries; 100% pure static Go

100% Native Standard Git on-disk format — zero vendor lock-in

Module 01 • Git Protocols 03 / 20

Git Smart HTTP & Native SSH Daemon

High-speed wire protocol implementation supporting concurrent clone, fetch, and push over TLS and SSH.

1. Git Smart HTTP Protocol (Port 3000 / 3443)

Info Discovery: GET /owner/repo.git/info/refs?service=git-upload-pack streams framed packet-lines directly from the bare repository with zero buffering.

RPC Streaming: POST /owner/repo.git/git-upload-pack (clone/fetch) and git-receive-pack (push) pipe standard streams through authenticated HTTP Basic credentials or tokens.

Download Guard: Validates user permission; blocked immediately if repository or user has can_download = false.

2. Built-in SSH Daemon (Port 2222)

Pure-Go Daemon: Powered by golang.org/x/crypto/ssh. Does not touch host /etc/ssh, preventing port 22 conflicts and host key tampering.

Database Key Auth: Validates developer RSA, ECDSA, and Ed25519 public keys against SQLite/PostgreSQL with sub-millisecond lookup.

Execution Sandbox: Restricts commands to git-upload-pack, git-receive-pack, and git-upload-archive with strict path sanitization.

# Both protocols work out of the box with standard Git clients
git clone https://git.company.com/engineering/backend-service.git
git clone ssh://git@git.company.com:2222/engineering/backend-service.git

Module 01 • Git Workflows 04 / 20

Branches, Default Branch Settings & Protections

Granular branch orchestration: global default branch policies, per-repo overrides, and branch protection rules.

Global & Per-Repo Default Branch

Configure instance-wide default branch (e.g. main, trunk, dev) in Admin Configuration, with per-repository overrides dynamically updating HEAD on disk via git symbolic-ref.

Introduced in v1.5.0 Settings

Branch Protection Rules

Prevent unauthorized modifications on critical branches: require code reviews before merge, enforce minimum approval thresholds, and forbid accidental or malicious force-pushes (git push --force).

Protection Matrix Enforced

Code Navigation & Blame

Lightning-fast branch comparison, side-by-side unified diffs, inline commit history, syntax-highlighted blob viewer, and line-by-line git blame with direct commit attribution.

Code Browser High Speed

Branch Protection Enforcement Pipeline

1. Git Push / PR Initiated

→

2. Rule Evaluation (Protected Branch?)

→

3. Approval Gate Checked (≥ N approvals)

→

4. Fast-Forward Merge to Default Branch

Module 02 • Installation 05 / 20

Zero-Friction Web Installation Wizard

Install, provision, and lock ProGit in under 60 seconds with an interactive web GUI or automated silent setup.

Setup Steps at /install

1. Instance Configuration: Define Application Name, Domain Hostname, Public Root URL, HTTP/HTTPS Ports, and Default Branch.

2. Super Admin Account: Create the root Super Administrator username, corporate email, and password.

3. Automatic DB Migration: Applies SQLite/PostgreSQL schema migrations and seeds system configuration tables.

4. Tamper-Proof Lock: Writes INSTALL_LOCK = true into app.ini and seals the installer permanently against replay attacks.

Headless & Container Auto-Provisioning

For CI/CD and automated Kubernetes GitOps rollouts, ProGit supports silent auto-installation through environment variables without opening the browser installer:

# Automated headless container deployment
ENV PROGIT_APP_NAME="Corporate Git"
ENV PROGIT_DOMAIN="git.internal.net"
ENV PROGIT_ROOT_URL="https://git.internal.net:3443/"
ENV PROGIT_HTTPS_PORT=3443
ENV PROGIT_SSH_PORT=2222
ENV PROGIT_INSTALL_LOCK=true

Security Guarantee: Strict Installation Lock

Once INSTALL_LOCK = true is set or any user exists, GET /api/v1/install/status reports locked and POST /api/v1/install unconditionally returns 403 Forbidden, preventing hostile admin takeover.

Module 02 • Container Deployment 06 / 20

Single-Command Podman & Docker Deployment

Production-ready rootless container runtime with isolated volume persistence, SELinux support, and multi-arch OCI images.

# Recommended Production Deployment Command (Podman / Docker)
podman run -d --name progit \
  --restart unless-stopped \
  -p 3000:3000 -p 3443:3443 -p 2222:2222 \
  -v progit-data:/data/db:Z \
  -v progit-repositories:/data/repositories:Z \
  -v progit-config:/data/config:Z \
  -v progit-logs:/data/logs:Z \
  localhost/progit:1.7.0

Port Mapping Matrix

• 3000: HTTP plain / auto-redirect
• 3443: Pure-Go TLS HTTPS server
• 2222: Native SSH Git transport

Volume Layout (SELinux :Z)

• /data/db: SQLite WAL database
• /data/repositories: Bare Git stores
• /data/config: TLS certs & app.ini
• /data/logs: Audit & runtime logs

Multi-Arch OCI Image

Multi-stage build based on Alpine Linux 3.21 with tini PID 1 zombie reaper, Git CLI, and non-root progit:progit user (UID 1000).

Module 02 • Security Hardening 07 / 20

Pure-Go Native HTTPS & Zero-Trust Hardening

Zero external Nginx or certbot dependencies: built-in ECDSA TLS auto-generation, ACME, and defense-in-depth protections.

Native TLS Architecture

Self-Signed ECDSA P-256: On startup, ProGit automatically checks /data/config/https/. If absent, generates an ECDSA certificate in 5 milliseconds.

Let's Encrypt ACME: Toggle ENABLE_ACME = true for automated TLS provisioning & renewal on public domains.

HTTP to HTTPS Redirect: Port 3000 automatically performs HTTP 301 redirects to HTTPS port 3443 with HSTS preload headers.

Zero-Trust Security Controls

Non-Root Execution: Container runs as unprivileged user progit (1000:1000) with no root capabilities required.

SSRF & Rebinding Protection: Webhook deliveries and Developer DNS queries restrict internal IP ranges (RFC 1918) and enforce IP pinning.

Rate Limiting & Scopes: Per-IP burst rate limiters and granular Personal Access Token scopes (repo, user, admin).

TLS 1.3Modern Cipher Suites

ECDSAP-256 Curve Default

HSTSStrict Transport Security

Zero RootRootless Podman Ready

Module 03 • Administration 08 / 20

Super Administration & Access Governance

Granular identity management, code exfiltration prevention, and per-user creation quotas.

Role-Based Access Control

• Super Admins: Global instance governance, config edits, repository moderation, maintenance execution.
• Standard Users: Scoped strictly to authorized organizations and personal repositories.
• Suspended Accounts: Instant session termination and token revocation.

User Governance RBAC

Download Restriction Mode

Toggle can_download: false per user. Contractors can read code in the web browser, but are blocked from:

• ZIP archive downloads (403)
• Raw file downloads (403)
• Repository forking (403)
• git clone & git pull via HTTP/SSH

Data Loss Prevention DLP Guard

Per-User Creation Quotas

Prevent server disk bloat by enforcing granular creation caps:

• max_repo_creation: Cap repos owned by user (e.g. 5, or -1 for global).
• max_org_creation: Cap orgs created.
• Super Admins bypass quotas automatically.

Quota Management Configurable

# Admin API Endpoint: Restrict code download on contractor account
curl -X PATCH "https://git.company.com/api/v1/admin/users/42" \
  -H "Authorization: Bearer <ADMIN_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"can_download": false, "max_repo_creation": 3}'

Module 03 • Administration (v1.7.0) 09 / 20

Global Admin Repository Search & Filtering

Search across all repositories in the instance, filter by visibility and archive status, and bypass the legacy 100-repo cap.

Multi-Field Server Search Engine

Faceted Queries: GET /api/v1/admin/repos?q=... queries across repository name, owner username, owner/name, description, and default branch with SQL wildcard escaping.

Prioritized Ranking: Exact matches score higher than prefix matches, returning the most relevant repositories first.

Beyond 100 Repositories: Instances with thousands of repositories can paginate (limit=500) and search smoothly.

Visibility & State Filters

Filter by Scope: Dedicated visibility parameter supporting:

• all: Complete instance view
• public: Public open-source repos
• private: Proprietary private repos
• archived: Read-only locked repos
• active: Active non-archived repos

Admin Controls: Quick one-click Git GC and Delete Repo from each row.

# Search repositories across entire enterprise instance
curl -X GET "https://git.company.com/api/v1/admin/repos?q=billing&visibility=private&limit=100" \
-H "Authorization: Bearer <ADMIN_TOKEN>"

Module 03 • Administration (v1.7.0) 10 / 20

The Git Management Dashboard

Live Git CLI engine telemetry, bare storage metrics, object-store inspector, and safe administrative maintenance.

git 2.47+ Installed Engine Version

Live Disk Scan Total Bare + Wiki Bytes

Object Store Loose vs Packed Objects

Global GC One-Click Instance Optimization

Live Object-Store Inspector

Inspect any repository with GET /api/v1/admin/git/repos/{id}:

• HEAD reference & branch / tag counts
• Loose object count & loose size (KB)
• In-pack objects & packfile count
• Prune-packable objects & garbage files
• Wiki repository disk size

Safe Administrative Operations

Execute path-validated maintenance via POST /api/v1/admin/git/maintenance:

• gc: Runs git gc --prune=now to repack & prune.
• repack: Runs git repack -a -d.
• fsck: Verifies SHA integrity with git fsck --no-dangling.
• gc_all: Sequentially garbage-collects all repositories.

Module 04 • Operations & HA 11 / 20

SQLite WAL Mode & Database Maintenance

Concurrent read/write architecture, zero-locking transactional write-ahead logs, and online VACUUM defragmentation.

SQLite in Write-Ahead Logging (WAL) Mode

Non-Blocking Concurrency: Readers never block writers, and writers never block readers. HTTP reads execute concurrently at 20,000+ RPS without database lock contention.

Memory Synchronization: Changes write sequentially to progit.db-wal before checkpoints commit them back to the main database pages.

Dual-Engine Support: Open Source uses pure-Go SQLite; Enterprise Edition adds native PostgreSQL support for multi-node clusters.

Online Maintenance Operations

1. Checkpoint & Truncate WAL:
Executes PRAGMA wal_checkpoint(TRUNCATE) to flush pending write buffers and truncate the WAL journal to 0 bytes without locking.

2. Database VACUUM:
Executes SQLite VACUUM to rebuild the database file, defragment B-tree pages, and reclaim disk space from deleted users/repos.

# Trigger online WAL checkpoint via Admin Maintenance API
curl -X POST "https://git.company.com/api/v1/admin/maintenance" \
  -H "Authorization: Bearer <ADMIN_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"operation": "checkpoint_wal"}'

Module 04 • Operations & DR 12 / 20

24/7 Operations, Backup & Disaster Recovery

Simple, foolproof disaster recovery: snapshot 3 directories, zero database corruption risks, and automated health checks.

Disaster Recovery Procedure

Step 1: Checkpoint DB: Trigger checkpoint_wal via API or cron to ensure zero unflushed WAL frames.

Step 2: Archive Volumes: Tar/snapshot the 3 persistent directories:

tar -czvf progit-backup.tar.gz /data/db /data/repositories /data/config

Step 3: Instant Restore: Untar to fresh host and start the container. ProGit boots in 1.2 seconds.

Production Health Probes

Liveness Probe (/api/health): Verifies SQLite DB ping, bare repository storage directory accessibility, uptime, and version. Returns 200 OK or 503.

Readiness Probe (/api/ready): Instant Kubernetes probe returning 200 OK once HTTP routers are bound.

Zero-Downtime Container Upgrades: Pull new tag (e.g. localhost/progit:1.7.0), stop old container, start new container pointing to same volumes.

< 2sContainer Boot & Recovery Time

3 PathsComplete State: db, repositories, config

RPO < 5mRecovery Point Objective with Hourly Backup

Module 05 • Product Uses 13 / 20

Enterprise Use Cases & Sovereign Engineering

From air-gapped defense labs to high-velocity software engineering teams: where ProGit delivers sovereign superiority.

Air-Gapped & Defense Labs

100% sovereign operation with zero external internet dependencies. No telemetry phone-home, no license activation ping, zero public cloud leakage. Complies with strict military and national defense data residency.

Banking & FinTech Core IP

Financial institutions cannot risk hosting proprietary algorithmic trading, payment gateways, or customer KYC code on shared multi-tenant SaaS clouds. ProGit guarantees on-premises cryptographic security.

High-Velocity Engineering

Eliminate public cloud latency and outages. Local gigabit LAN clone/push operations run at wire speed (sub-second clones for 1GB+ repos), supercharging CI/CD pipelines and developer throughput.

Multi-Organization Developer Collaboration

ProGit allows structuring code across independent Organizations with Teams (Owners, Admins, Developers), private/public repo visibility, issue trackers, and team-based pull request review workflows.

Module 05 • Developer Toolbox 14 / 20

Built-in Developer Toolbox (`/toolbox`)

11 zero-overhead developer utilities with instant ⌘K search, Favorites, and two-level lazy code-splitting.

Security & Auth

• Password Generator: Cryptographic passwords & passphrases.
• JWT Debugger: Header, payload & expiry decode.
• Hash & HMAC: SHA-256/512, MD5, Keccak.

Encoders & Formats

• Base64 / URL: Text & binary encoding.
• JSON Formatter: Prettify, minify, validate.
• XML & YAML: Format & YAML-JSON convert.

Code & Scheduling

• UUID Generator: v4 & v7 time-sorted.
• Cron Parser: Human schedule + next 5 runs.
• Text Diff: Side-by-side unified comparison.

Network & DNS

• Bounded DNS: Query A, AAAA, CNAME, MX, TXT, NS, PTR.
• Rate Limited: 30 req/min per user.
• Concurrency Cap: 8-slot worker gate.

Zero Performance Overhead Architecture

Both the /toolbox landing hub and each individual tool chunk load strictly on-demand via dynamic imports. Developers browsing code, repositories, or issues pay 0 KB extra bundle size. Dropdowns use ProGit's custom ThemedSelect component without card clipping.

Module 05 • Collaboration Tools 15 / 20

Projects, Wikis, ProGit Pages & Direct Messaging

A full-featured developer platform: Kanban boards, static site hosting, and secure internal communication.

Kanban Projects

Drag-and-drop boards per repository. Custom workflow columns, card reordering, and direct Issue linking.

Multi-Tenant Wiki

Every repo gets a dedicated .wiki.git Git repository. Markdown editing in UI or cloneable locally via standard Git.

ProGit Pages

Host documentation or static sites directly from repo branches at /pages/{owner}/{repo}/ with owner-only toggles.

Developer Messages

Built-in peer-to-peer developer communication without relying on third-party Slack or external chat tools.

Webhooks & Event Integration

ProGit delivers cryptographic HMAC-SHA256 signed JSON payloads on push, pull request, issue, and release events to Jenkins, Drone CI, ArgoCD, or custom internal webhooks with full retry logs.

Module 06 • Verified Performance 16 / 20

Verified Benchmark: 18,000+ API Requests/Sec

Rigorous local container benchmark results on ProGit v1.7.0 under high concurrency across 7,440 requests (0 errors).

API Endpoint	Requests	Concurrency	Throughput	p50 Latency	p95 Latency	p99 Latency
`GET /api/health`	2,000	50	17,945.7 req/s	1.97 ms	8.64 ms	12.86 ms
`GET /` (Embedded SPA Bundle)	1,000	30	18,352.2 req/s	1.59 ms	2.51 ms	3.00 ms
`GET /api/v1/features`	1,500	40	21,775.8 req/s	1.72 ms	3.15 ms	3.95 ms
`GET /api/v1/explore` (150 repos)	800	25	3,774.1 req/s	4.34 ms	19.12 ms	28.93 ms
`GET /api/v1/admin/repos?q=...`	500	20	2,012.9 req/s	9.25 ms	20.03 ms	26.10 ms
`GET /api/v1/admin/repos?visibility=private`	400	20	3,477.5 req/s	4.16 ms	13.71 ms	17.75 ms
`GET /api/v1/admin/git` (150 bare scan)	40	4	198.8 req/s	19.98 ms	21.41 ms	22.48 ms

Benchmark conducted on standard local container runtime over pure-Go TLS. Total error rate: 0.00%. Sub-3ms p50 Core Latency

Module 06 • Resource Footprint 17 / 20

Git Operations Speed & 45 MB RAM Footprint

Compare ProGit's featherweight memory consumption against monolithic enterprise Git platforms.

Concurrent Git Clones

625 ms

Total wall-clock time for 5 parallel HTTPS Git clones on freshly initialized bare repositories. Individual clone latency: 149ms – 625ms.

Concurrent Git Pushes

788 ms

Total wall-clock time for 5 parallel commits and pushes with wire-speed Git packfile negotiation and ref updates.

Global GC (150 Repos)

1.47 s

Sequential git gc --prune=now execution across 150 bare repositories on disk in the Git Management Dashboard.

Memory Consumption Comparison: ProGit vs Competitors

Platform	Idle Memory	Under Full Load	Database Daemon	Architecture Stack
ProGit (v1.7.0)	3.8 MB	45 MB peak	Embedded SQLite WAL	Single static Go binary
Gitea / Forgejo	120 MB	350 – 600 MB	External / Embedded	Go + CGO / Node assets
GitLab CE / EE	4,000 MB (4 GB)	8,000 – 16,000 MB	PostgreSQL + Redis	Ruby on Rails, Puma, Sidekiq, Gitaly

Module 07 • Cost Analysis 18 / 20

Interactive 3-Year TCO & ROI Calculator

See how switching to ProGit saves between 75% and 85% in software licensing and cloud compute costs.

Developer Team Size 100 Developers

• GitHub Enterprise: $21 / user / month
• GitLab Ultimate: $99 / user / month
• ProGit Open Source: $0 / user (Sovereign Forever)
• ProGit Enterprise: $6 / user / month

Estimated 3-Year Savings vs SaaS

$142,560

82% Cost Reduction

GitHub 3-Yr Cost

$75,600

GitLab 3-Yr Cost

$356,400

ProGit 3-Yr Cost

$21,600

Hosting Infrastructure Savings

ProGit runs on a $5/mo VPS (1 vCPU, 512MB RAM). GitLab requires an 8GB RAM / 4 vCPU instance ($80–$160/mo), saving $5,000+ over 3 years in raw compute.

Zero Hidden Dependencies

No external Redis licenses, no Elasticsearch cluster maintenance costs, and no PostgreSQL DBA overhead required for standalone instances.

Total Data Sovereignty

Zero per-minute CI compute markups, no surprise egress bandwidth charges, and 100% intellectual property ownership in your private cloud.

Module 07 • Commercial Options 19 / 20

Transparent Editions & Enterprise Scalability

100% free Sovereign Open Source Edition alongside Enterprise Edition with High-Availability clustering and SSO.

Community • Self-Hosted

ProGit Sovereign (OSS)

$0 / forever

✓ Unlimited users, repositories, organizations

✓ Native HTTPS, SSH daemon, Smart HTTP

✓ Global admin repo search & Git Management Dashboard

✓ Built-in Developer Toolbox (11 tools)

✓ Projects, Wikis, Pages, Messaging, Webhooks

✓ Embedded SQLite with online WAL checkpoints

Enterprise • Mission Critical

ProGit Enterprise (EE)

$6 / user / month

✓ Everything in Sovereign Edition

✓ Multi-Node HA Clustering: Active-active cluster with Raft

✓ PostgreSQL Dual Engine: Clustered HA backend

✓ Enterprise Identity: LDAP / Active Directory & SAML 2.0 / Okta

✓ SIEM Audit Logging: Tamper-evident cryptographic audit logs

✓ Priority SLA: 24/7 enterprise engineer response

Conclusion 20 / 20

Get Started with ProGit in 30 Seconds

Join the sovereign Git movement: ultra-fast, zero-CGO, lightweight, and completely under your own control.

# 1. Pull and run the official container
podman run -d --name progit -p 3000:3000 -p 3443:3443 -p 2222:2222 \
-v progit-data:/data/db:Z -v progit-repositories:/data/repositories:Z \
localhost/progit:1.7.0

# 2. Open in your browser to complete the wizard
open https://localhost:3443/install

Documentation Portal →

Complete user guides, administrator manual, REST API specification, and Docker/Podman deployment playbooks.

Git & CI/CD Tutorial →

Exhaustive chapter-by-chapter masterclass covering Git fundamentals, branching, merge conflicts, and GitHub Actions recipes.

GitHub Repository ↗

Star the open-source repository, view commit history, contribute pull requests, and file feature proposals.

Open Documentation Portal →