Skip to content

Engineering standards you can actually verify

Developer Portal · Internal portal and engineering standards

Inventory, blueprint, standards and an engineering score for each repository, run together with the AIUBY team. On top of the delivery graph, the software catalog shows who owns each service, scorecards grade with evidence, golden paths generate new services that follow the standard, and extensions add on-demand environments with forecast cost, plugins and entity types shaped to your needs.

The problem

What this product solves

An engineering standard written in a wiki does not change the repository: each team reads it its own way.

Without a reliable catalog, nobody can quickly say which service depends on which, who owns it or where the runbook is.

And every new service starts as a copied repository, inheriting the drift of the previous one.

updated

Who uses it, and for what

Typical profiles, no customer names. Each use carries the status of the feature behind it.

  • Engineering leadership at a growing teamWrite the engineering standards into the repository and measure every team against them.Engineering standards
  • Platform teamKnow which service depends on which, who owns it and how each one scores against house rules.Service catalog
  • Developer creating a new serviceGenerate the skeleton in the team standard from a template and receive a draft pull request.Self-service

Features

What the product does

Self-service: add it from your account.

  • Engineering standards

    Inventory, blueprint, standards and engineering score tracked with the AIUBY team.

  • Service catalog

    Services, systems, APIs and owners (team or person) on the delivery graph, with lifecycle, tier, links and the aiuby.yaml descriptor read from the repository (read-only).

  • Scorecards

    Declarative rules (owner, runbook, SLO, critical findings, dependencies, progressive rollout, CI) evaluated on the graph: score per service and team, weekly history and the evidence for each rule.

  • Self-service

    Golden paths: templates with typed parameters generate files by text substitution (nothing is executed), downloadable as zip or patch, or as a proposal that becomes a draft PR through Code Automation after someone else approves. On-demand environments that trigger a pipeline are handled by the portal extension blueprints.

  • Portal adoption

    How much of the catalog is filled in (owner, descriptor, repository, lifecycle), how many services have a score and how much golden paths are used, with a 12-week series. Counts only, from what the portal stores: no page-view tracking and no per-person numbers.

  • Portal extensions

    Cross-source aggregation rules, environment blueprints with cost estimates, four-eyes environment requests that trigger the pipeline, HTTPS plugins and custom entity kinds.

Engineering standards, with the AIUBY team: in detail

  • Engineering assessment
  • Installation in the repository
  • Rollout across teams
  • Monthly follow-up
  • Training on your real repository

What it does not do

  • It is a service, not software: everything lands as a pull request in your Git.
  • It does not build features or maintain your application.

How it works

From start to audit record

  1. Survey and standardize

    The AIUBY team builds the inventory with your team and writes the blueprint and standards into the repository, through pull requests.

  2. Measure the round

    The engineering score is published with history, per squad, and compared with the starting point.

  3. Describe the service

    An aiuby.yaml file in the repository declares owner, tier, lifecycle, system, dependencies, APIs and links.

  4. Sync the catalog

    The platform reads the descriptor with a read-only credential and links the service to the repository in the delivery graph.

  5. Grade with rules

    Scorecards check owner, runbook, SLO, findings, CI and rollout, and store the weekly score with the evidence.

  6. Build on the paved path

    The template generates the new service files. The proposal, approved by someone else, becomes a draft pull request.

  7. Request the environment

    The blueprint shows the forecast monthly cost. Once someone else approves it, the request triggers the pipeline that brings the environment up.

Features

Feature by feature

What each one does, how it works, an example from the documentation and what it does not do. Each badge comes from the catalog.

Engineering standards

Standards written into the repository, and a score that tracks progress

The AIUBY team works with yours to map the engineering inventory, design the architecture blueprint, write the standards and measure each round with a score. Standards and blueprint land in your repository through a pull request, reviewed by the code owners.

The organization's signed-in area holds the inventory, the blueprint, per-squad indicators and the score with its history, always stamped with when the team published the reading.

How it works

  • An inventory of what exists in engineering: installed items, items new in the round and reusable standards.
  • An architecture blueprint with the status of each item, published with the round.
  • An engineering score from 0 to 100, with a level, weekly history and a comparison with the starting point.
  • Per-squad indicators in the same publication, so teams are compared on the same yardstick.
  • Only the published round is visible to the organization: team drafts never reach the screen.
  • Every change to the repository goes in through a pull request that your team reviews and merges.

Example use case

A company with five squads keeps its engineering standards in a wiki that each team reads differently. The AIUBY team maps the inventory, writes the blueprint and standards into the repository through a pull request and publishes the first score. Each round, leadership opens the signed-in area, compares the score with the starting point and sees which squad has not adopted the standard.

What it does not do

  • It is not self-service: the AIUBY team runs the assessment and publishes each round.
  • The score is not recalculated automatically on every commit; it changes when a new round is published.
  • It is not purchased through the account: the work is an engineering service, arranged with the team.

Service catalog

Who owns it, what it depends on and where the runbook is

The software catalog is a view on the platform's delivery graph: services, systems, APIs, owners, dependencies and repositories are entities and edges of the same graph that receives deployments, incidents and findings. Nothing is copied into a parallel database.

Each service can be described in an aiuby.yaml file at the root of the repository's default branch. The platform reads the file through the GitHub API, with a read-only credential, and applies lifecycle, tier, owner, system, dependencies, APIs and links.

How it works

  • Owner of type team or person: the team is the same label used in AI adoption, and a person only counts if they can see the workspace.
  • Lifecycle (experimental, production, deprecated) and tier from 1 to 4, where 1 is the most critical.
  • A dependency on a service that is not in the catalog comes back as a warning, not an error, and stays visible for correction.
  • A repository cannot change a service built from another repository: the sync responds with a conflict.
  • Strict YAML reader: it refuses anchors, tags, multiline blocks, duplicate keys and out-of-format fields, with a cap of 32 KB and 1,000 lines.
  • Read access through API v1, the CLI (aiuby catalog list and aiuby catalog get) and the MCP server, with a key scoped to engineering:read.
Descriptor in the repository The aiuby.yaml file describes the service; the sync creates or updates the catalog entry and links it to the repository.
apiVersion: aiuby.dev/v1
kind: Service
metadata:
  slug: checkout                 # service identifier in the catalog
  description: Cart checkout
spec:
  lifecycle: production          # experimental | production | deprecated
  tier: 1                        # 1 (most critical) to 4
  owner: team:Payments           # team:<team name> or user:<email of a workspace member>
  system: commerce               # system identifier
  dependsOn: [catalog, payments-gateway]
  apis:
    - name: checkout-api
      type: openapi              # openapi | grpc | graphql | asyncapi | other
  links:
    - title: Runbook
      type: runbook              # runbook | docs | dashboard | repo | oncall | other
      url: https://wiki.example.com/checkout/runbook

What it does not do

  • It does not discover aiuby.yaml across all repositories on its own: sync runs per repository, requested by a workspace admin.
  • It writes nothing to the repository and does not fetch the registered links; the API definition is only a reference and is not read.
  • It has no custom entity kinds or plugins.
  • Only workspace admins edit the catalog; everyone else reads it.

Scorecards

One score per service, with the evidence for each rule

A scorecard is a list of weighted declarative rules, evaluated on facts the platform knows: owner in the graph, service links, SLOs, open security findings, pipelines and deployments. No customer code runs to produce the score.

Evaluation is deterministic. The score is the weight of the rules that passed divided by the weight of the rules that apply to the service, and each result carries the evidence text and the reference to the finding, SLO, pipeline run or entity.

How it works

  • Nine checks from a closed list: owner, link by type (runbook, for example), SLO, open findings by severity, dependencies with a fix, progressive rollout, passing CI, descriptor and tier.
  • Each rule has a weight from 1 to 10 and can apply only to certain lifecycles and tiers; outside its target, the rule does not count toward the score.
  • Versioned rules: changing the scorecard bumps the version.
  • History of one score per scorecard, service and week. The worker re-evaluates weekly, and admins can evaluate on demand.
  • Team score: the average of the scores of the services the team owns.
  • Read access through API v1, the CLI (aiuby scorecard) and the MCP server (scorecard type).
Through the CLI and the API The routes are read-only and require a key with the engineering:read scope.
# Scores for a service, with the evidence for each rule
aiuby scorecard <service>

# Scorecards in the workspace, with last week's average
GET /api/v1/engineering/portal/scorecards

# Rules with formula, score per service and per team, history
GET /api/v1/engineering/portal/scorecards/{id or slug}

What it does not do

  • It does not accept customer-written checks: rules come from the closed list.
  • A service without a linked repository fails the findings and CI checks, because there is no way to prove them.
  • The team score uses the owner at evaluation time; ownership history is not kept.
  • There are no aggregation rules across scorecards; the cap is 20 scorecards per workspace.

Self-service

New services start on the standard, without copy-pasting a repository

Golden paths are templates with typed parameters and files with placeholders. Whoever creates a service fills in the parameters, and the platform generates the files through text substitution in a single pass: the inserted value is never reprocessed or executed.

The output is a download (zip or a patch for git apply) or a proposal: another person approves, and the result becomes a draft pull request in the repository, created by the same writer Code Automation uses. The platform merges nothing.

How it works

  • Parameters with type and format: text (slug, identifier or free text), number with minimum and maximum, boolean and list of options.
  • Case filters on placeholders (upper, lower, kebab, snake, pascal); expressions from other tools, such as GitHub Actions expressions, stay intact.
  • A template with a placeholder for an undeclared parameter is refused on save; a value out of format or with a line break is refused on generation.
  • Each file path is checked after substitution: relative, no parent traversal, no .git and no duplicates.
  • Proposals with separation of duties: the requester does not approve, and the file hash must match what was approved.
  • The pull request only carries new files; a file that already exists on the base branch causes creation to be refused.

Example use case

The platform team publishes an HTTP service template with the parameters name, owning team and port. A developer fills in all three, checks the generated files and submits them as a proposal. The tech lead approves, and the draft pull request appears in the repository with the pipeline, the Dockerfile and the aiuby.yaml filled in. The team reviews and merges it like any other PR.

What it does not do

  • The template does not run a pipeline or create an environment: it generates files. On-demand environments are handled by the portal extension blueprints.
  • It does not change existing files or merge the pull request.
  • A proposal that becomes a PR requires Code Automation to be on and a write credential registered in the workspace; without them, delivery is a download.
  • Caps: 30 parameters and 50 files per template, 50 active templates and 200 generations per day per workspace.

Portal adoption

See whether the portal is being used, with the portal's own numbers

The adoption screen answers three questions for the platform team: how much of the catalog is filled in, how many services have a scorecard score and how many times golden paths generated code. Everything is counted on the fly, from the tables the portal maintains.

How it works

  • Catalog completeness: services with an owner, with a synced aiuby.yaml descriptor, with a linked repository and with lifecycle set.
  • Coverage of active scorecards: services with a score in the last evaluated week and the average of those scores.
  • Golden path usage: generations, pull request proposals, pull requests created and rejected proposals.
  • A 12-week series (Mondays, UTC) with generations, pull requests, scored services and average score.
  • Warnings about what is missing for the portal to be used: empty catalog, no active scorecard or no golden path.
  • Read access through API v1 with the engineering:read scope.
Through the API The route is read-only and requires a key with the engineering:read scope.
# Portal adoption in the key's workspace
GET /api/v1/engineering/portal/adoption

What it does not do

  • It does not measure page views, searches or time spent: only what is stored in the portal.
  • No number is per person; the screen only shows how many people generated from a template.
  • Catalog reading stops at 500 services per workspace, and the series is fixed at 12 weeks.

Portal extensions

A portal shaped to the way your team works.

Portal extensions cover what varies from company to company: which tool to trust for each field, which environments a team can request on its own and what they cost, what outside information appears next to a service and which kinds of things the catalog needs to know beyond the defaults.

Environment requests complete the self-service that golden paths start: the platform team describes the environment once, with its estimated cost, and developers request it when they need it. Nothing spins up before another person approves, and what spins up is the pipeline the platform team wrote.

How it works

  • Aggregation rules: for a field of a kind, the trust order of the sources. The aggregated entity merges what each source says, field by field, and shows where each value came from.
  • Environment blueprints: Compute size, replicas, hours per month, extra fixed cost, IaC workspace and creation pipeline, with the monthly cost estimated from the price table before anything is created.
  • Four-eyes environment requests: the requester does not approve. Once a workspace admin approves, the blueprint pipeline is triggered with the request parameters.
  • HTTPS plugins: the endpoint receives the entity summary and returns up to 10 text cards, with internal networks blocked, no redirects, a response within 4 s and 32 KB, and no credentials sent.
  • Custom entity kinds (queue, cloud account, contract, whatever your catalog needs), with up to 30 typed fields (text, number, yes or no, address) and a catalog owner.

Example use case

The platform team creates a staging blueprint with two small containers and the pipeline that spins up the environment. A product person requests an environment for their branch and sees the estimated monthly cost. The tech lead approves, and the pipeline starts with the branch as a variable.

What it does not do

  • Nothing is created in the cloud without approval from a person other than the requester.
  • Plugins do not run code on AIUBY or return HTML: only text cards.
  • The estimate uses the Compute table and the fixed cost provided; other cloud costs are not included.
  • Caps per workspace: 100 aggregation rules, 50 blueprints, 20 plugins, 30 kinds and 2,000 custom entities.

Governance and security

Rules the code enforces

  • Everything that enters your repository enters through a pull request reviewed by your team. The platform merges nothing.
  • The aiuby.yaml descriptor is read with a read-only credential, and one repository cannot change a service built from another repository.
  • Only workspace admins edit the catalog, scorecards and templates. Everyone else reads.
  • Scorecard rules come from a closed list of checks: no customer code is executed to compute a score.
  • File generation is single-pass text substitution: inserted values are never reprocessed or executed.
  • In a golden path proposal, the requester does not approve, and the pull request carries only new files, with the same hash that was approved.
  • In an environment request, the requester does not approve, and the pipeline only runs after a workspace admin approves.
  • Plugins are called over HTTPS without credentials, with the internal network blocked and responses limited to text cards.
  • API v1, the CLI and the MCP server are read-only, each with its own scoped key.

Integrations

What it connects to

Only integrations that exist in the code. Each one carries the status of the feature that uses it.

  • GitHubThe aiuby.yaml descriptor is read from the repository default branch, read-only.Service catalog
  • Delivery graphServices, systems, APIs, owners and dependencies are entities in the platform graph.Knowledge Graph
  • Scanners, SLOs and pipelinesOpen findings, SLOs and the latest run of each pipeline are the rule sources.Scorecards
  • Code AutomationThe approved proposal becomes a draft pull request through the same writer, with the same guardrails.Self-service
  • Pipelines and ComputeThe blueprint points to the pipeline that brings the environment up and uses the Compute rate table to forecast the monthly cost.Portal extensions
  • HTTPS pluginsAn endpoint of yours receives the entity summary and returns text cards shown next to the service.Portal extensions
  • API v1 and CLICatalog and scores through read endpoints and the aiuby catalog and aiuby scorecard commands.API, CLI & keys
  • MCP serverServices with owner, system, links and scores, plus the scorecard type, for coding assistants.MCP server

FAQ

Straight answers

What can I use today?

Available: Engineering standards, Service catalog, Scorecards, Self-service, Portal adoption, Portal extensions. Self-service: add it from your account.

Is it a full self-service portal?

Available: Self-service, Portal extensions, Engineering standards. Self-service has two parts. Golden paths generate the files for a new service, as a download or as a draft pull request after someone else approves. Environment blueprints let you request an environment with its forecast monthly cost, and once someone else approves, the request triggers the pipeline the platform team defined. Engineering standards are run with the AIUBY team.

Why can I not sign up for it from my account?

Available: Engineering standards, Service catalog, Scorecards, Self-service. Because engineering standards depend on work by our team in your repository. Engineering services have their scope and price range on the Services page. Catalog, scorecards, golden paths and extensions use the Cortex contract and are configured with our team.

Does it import the catalog or plugins from another portal?

Available: Service catalog, Portal extensions. No. The catalog has its own format, aiuby.yaml, and does not run UI plugins from other portals. You can extend it the AIUBY way: custom entity types with typed fields, rules for which source wins for each field and HTTPS plugins that return text cards. Services, repositories, owners and dependencies live in the same graph that receives deployments, incidents and findings.

What can a scorecard check?

Available: Scorecards. Nine checks from a closed list: owner, link by type (runbook, for example), SLO, open findings by severity, dependencies with a fix available, progressive rollout, passing CI, synced descriptor and tier. Each rule has a weight, and the result shows the evidence. Checks written by the customer are not accepted.

Does the golden path create the repository and launch the service on its own?

Available: Self-service. No. It generates files by text substitution and delivers them as a zip, a patch or a draft pull request with new files. Nothing is executed, no existing file is changed and your team does the merge.

Where do standards, the catalog and scores live?

Available: Engineering standards, Service catalog, Scorecards. The standards, the blueprint and each service descriptor live in your repository. The inventory, the score, the catalog and score history live in the organization's web app, and are also available read-only through API v1, the CLI and the MCP server.

How do I get started?

Available: Engineering standards. With a conversation with our team, which defines the repositories in the survey. There is nothing to install: the work happens in the repository, through pull requests, and tracking happens in the web app.

Works together with

  • Software DeliveryPipelines and deployments with progressive rollout are facts that scorecard rules check.
  • Security TestingOpen scanner findings, by severity, count toward each service score.
  • Incident ManagementService SLOs count in the rules, and the catalog owner is the team accountable for the service.

Developer Portal

Self-service: add it from your account.