Engineering standards exist as tribal knowledge in the heads of senior devs and leads; when those people leave, standards evaporate because there's no enforceable, living record.
A platform where teams document architectural decisions, coding standards, and review checklists as structured rules. These rules integrate into CI pipelines to surface violations automatically, with context on why each rule exists so juniors understand the reasoning.
SaaS subscription tiered by team size ($200-800/month per team).
The pain is real — tribal knowledge loss from attrition is a universal engineering org problem. The Reddit signals confirm frustration. However, it's a slow-burn pain, not a hair-on-fire emergency. Teams tolerate bad standards for years before acting. The buying trigger is usually a major incident or key person departure, not proactive planning.
TAM for engineering teams of 10-100 engineers is substantial (hundreds of thousands of companies globally), but this is a niche within the broader DevEx/IDP market. At $200-800/month per team, a realistic serviceable market is $200-500M. The challenge is that 'engineering standards' competes for budget with broader IDP platforms that include standards as a feature, not the core product.
$200-800/month per team is reasonable but faces headwinds. Many teams cobble together free tools (Confluence + Semgrep + custom CI scripts) and consider it 'good enough.' Engineering managers have budget authority but standards tooling often loses priority to observability, CI/CD, and security tools. The buyer (eng manager) and the user (developer) have different incentives — managers want enforcement, developers resist it. Proving ROI requires attributing fewer bugs or faster onboarding to the tool, which is notoriously hard to measure.
A solo dev can build an MVP in 6-8 weeks: structured YAML/Markdown editor for standards, a CI/CD integration (GitHub Actions or GitLab CI) that runs checks and links violations back to documentation, and a simple dashboard. The hard part is the rules engine — supporting enough rule types (code patterns, dependency checks, config validation, architecture rules) to be useful across stacks without building N separate integrations. Starting with a Semgrep/linter wrapper layer is smart.
This is the strongest signal. No existing tool links documented standards (with rationale, context, examples) directly to automated CI/CD enforcement. Every competitor does one side or the other: Cortex/Port do scorecards without docs, Swimm does docs without enforcement, Semgrep does enforcement without docs. The 'why behind the rule' as a first-class citizen is a genuinely unoccupied position. The risk is that Cortex, Port, or Backstage ecosystem could add this capability as a feature.
Standards evolve constantly — new services, new patterns, new team members who need onboarding context. The compliance dashboard needs continuous monitoring. Once integrated into CI/CD pipelines, switching costs are high. Teams would pay monthly for ongoing enforcement, reporting, and the ability to evolve their standards over time. Strong natural retention once embedded in workflows.
- +Genuine white space — no tool combines living standards documentation with CI/CD enforcement and the 'why' behind each rule
- +High switching costs once integrated into CI/CD pipelines create strong retention
- +Pain is real and validated by practitioner discussions — tribal knowledge loss is a universal engineering problem
- +Platform engineering and IDP markets are growing 25-30% CAGR, tailwinds are strong
- +The 'educational enforcement' angle (violations show context and rationale, not just errors) is a compelling differentiator
- !Cortex, Port, or Backstage ecosystem could add rich documentation to their existing scorecards, collapsing the differentiation in 6-12 months
- !Willingness to pay is uncertain — many teams tolerate Confluence + ad-hoc linters as 'good enough' and may not see enough incremental value to justify a new tool
- !The buyer (eng manager wanting enforcement) and the user (developer resisting more process) are misaligned — adoption friction could be severe
- !Rules engine complexity grows fast — supporting enough languages, frameworks, and rule types to be useful across diverse stacks is a significant ongoing engineering burden
- !Long sales cycles for engineering tooling at the 10-100 engineer company size — these orgs often lack dedicated DevEx budget lines
Internal developer portal with service scorecards that grade services against defined standards, initiative tracking, and integrations with CI/CD and observability tools.
Open-source internal developer portal framework with TechDocs
Fast static analysis tool with custom rules written in a pattern-matching DSL. Finds code patterns and anti-patterns across 30+ languages with CI/CD integration.
Documentation platform that keeps docs coupled to code. Auto-detects when referenced code changes and flags staleness. IDE integration surfaces relevant docs while coding.
Internal developer portal with flexible data model, service catalog, scorecards with rule-based evaluation, self-service actions, and workflow automation.
A GitHub App that reads a .standards/ directory of Markdown files (each standard has frontmatter linking to Semgrep rules, custom checks, or CI scripts). On every PR, it runs linked checks and posts inline comments that include the standard title, a link to the full rationale doc, and the specific violation. A simple web dashboard shows compliance scores per repo and standard. Start with 3 built-in standard templates (API design, testing requirements, dependency management) so teams get value immediately without writing everything from scratch.
Free tier: up to 3 standards with basic CI checks for 1 repo. Paid ($200/mo): unlimited standards, unlimited repos, compliance dashboard, team management. Growth ($500/mo): multi-team standards inheritance, audit logs, custom rule SDK, Slack/Teams notifications. Enterprise ($800+/mo): SSO, RBAC, policy-as-code export, SOC2 compliance reporting, dedicated support.
3-5 months. Month 1-2: MVP with GitHub integration and basic standards templates. Month 2-3: Beta with 5-10 design partner teams from DevEx communities (Reddit, Discord, Hacker News). Month 3-5: First paying customers from beta cohort. The key accelerant is having opinionated starter templates so teams see value in under 30 minutes, not after weeks of writing standards from scratch.
- “The company has a history of questionable architectural decisions”
- “thoroughly documenting your team's processes”
- “People only adhere to processes when they either understand how they help them”
- “worried about what happens next after the lead leaves”