How a Frontend Monorepo Boosted Code Quality and Release Stability at Scale

Background: Rapid business growth led the frontend platform to manage over 170 applications by May 2023, exposing risks in release stability and code quality. In June 2023 a technical investigation of a "big warehouse" (monorepo) was conducted, and a systematic stability governance model was piloted in July, becoming fully operational in early 2024.

Governance System

The governance loop follows four steps: define metrics → set quarterly goals → track progress → quarterly review. Metrics are aligned across business domains and recorded in OKRs.

Define Metrics: Establish stability targets for the monorepo, ensuring cross‑domain relevance.

Goal Setting: Each quarter, domains adjust goals based on previous results and embed them in OKRs.

Process Tracking: Bi‑weekly platform meetings review domain‑level outcomes, with reminders for under‑performing areas.

Result Review: End‑of‑quarter OKR reviews compare actual outcomes against KR targets.

Key Governance Indicators

Five measurable indicators drive stability:

Git metadata size: Large metadata (>800 MB) slowed local Git commands and MR reviews. Optimization reduced average domain size to <60 MB.

Code quality score: Composite score from large files, function complexity, HTTPS checks, sensitive word detection, security scans, frontend calculations, and magic numbers. Scores rose from ~74 to >85.

Lint error score: Scored on error count (0‑100 errors = 4.12 points, etc.). Average score improved from ~10 to >13.

Workflow checkpoints: Strong and weak gates (branch name validation, lint checks, permission checks, cross‑domain changes, forbidden paths) prevented risky merges; >1,200 strong and >20,000 weak checks avoided ~130 incidents.

Code duplication rate: Measured reuse; reduced from ~12.5% to <8% (target <6%).

Technical Improvements

Git Metadata Performance

Wrapped git clone with a local cache, cutting clone time by ~90%.

Used git sparse-checkout to shrink initial clone to <10 s.

Dynamic splitting of monorepo metadata lowered total size from ~1 GB to <60 MB per domain.

Code Quality Scoring

Automated scans on each iteration compute a quality score based on the seven dimensions listed above. Quarterly targets (>80) guide domain‑level focus; most domains reached the threshold by Q3 2025.

Lint Standardization

Unified lint configurations across all applications using shared packages:

TypeScript: @xxxxx/ts-config/base.json ESLint: @xxxxx/eslint-config Stylelint: @xxxxx/stylelint-config Prettier: .prettierrc + VSCode settings

Git hooks enforce these standards on every commit, assigning a Lint error score (max 16.12 points) based on error count.

Workflow Checkpoints

Strong and weak gates are applied during MR and build stages. Strong gates (e.g., permission checks, branch‑app matching) block merges if violated; weak gates (e.g., branch name validation) issue warnings. Visual diagrams illustrate the checkpoint flow.

Code Duplication Monitoring

A VSCode extension provides real‑time duplication metrics, enabling developers to see duplication rates per branch instantly.

Results

No online smoke tests or incidents since the monorepo pilot.

Git metadata average reduced from 800 MB+ to <60 MB per domain.

Code quality score increased from ~74 to >85.

Lint error score rose from ~10 to >13.

Strong checkpoints executed >1,200 times, weak checkpoints >20,000 times, preventing ~130 potential incidents.

Duplication rate fell from ~12.5% to <8% (target <6%).

Conclusion

The frontend platform’s systematic monorepo governance—covering metric definition, goal setting, continuous tracking, and quarterly retrospection—has delivered a stable, high‑quality codebase across 200+ applications. Future work includes leveraging AI agents to further reinforce workflow stability.