Nylivo / Domains / Enterprise Technology

Enterprise Technology

The domain where Nylivo turns on its own engineering org rather than a customer-facing product. The source of truth is the deploy log, the incident timeline, and the on-call record — not whoever remembers what shipped last Tuesday at 4pm. A wrong root-cause guess burns error budget while on-call chases the wrong service; an unconfirmed fix pushed at production is how a contained incident becomes a second one.

Exploring Same Brain Same control plane Confirm-first
NOTE

Nothing here is built yet. This is the platform aimed at the engineering org itself rather than a customer-facing product — a considered direction, not a commitment to a date. What's real today is the substrate it would run on: the graph Brain, the connectors that already speak Git, issue trackers, SQL, and object storage, the approval rails, and the outcome ledger, all proven in production by QuantVantage.today. Published here because a platform claim you can't inspect isn't worth much.

Why this domain

The failure mode is the same one, wearing a pager.

Engineering operations isn't a stretch from fintech, retail, or real estate — it's the case where the platform's existing guarantees are tested at 3am instead of during a quarterly review.

Fit 01

A guess dressed as certainty is how postmortems go in circles

In an incident, "when did the metric turn red" and "what changed right before that" are graph facts with a source and a timestamp, not someone's recollection from the war room. Provenance matters more here, not less, because a wrong confident answer costs minutes an SLO doesn't have.

Fit 02

Blast radius is a graph traversal, not a glance at the dashboard

The service that actually broke is rarely the one paging — it's two or three hops away, through a shared queue, a shared connection pool, or a transitive dependency three teams silently rely on. Multi-hop traversal is the only way to surface that before the postmortem does.

Fit 03

Confirm-first and closed-outcome grading earn their cost at 3am

Nobody wants an autonomous rollback fired at production on a hunch, and a root-cause "hit rate" means nothing unless it's graded only against outcomes that actually closed. This is exactly the moment human confirmation and closed-outcome grading stop being nice-to-haves.

Workspace anatomy

Ingest. Graph. Triage. Grade.

The same four stages as every other workspace on the platform. Only stage three changes — here it's triage across incidents, code risk, and delivery blockers, not advising or underwriting.

Ingest

Every change gets one shared clock

The connector layer that already speaks Git, issue trackers, SQL, and object storage pulls deploy events, PR merges and diffs, CI pipeline runs, monitoring alerts, incident tickets, dependency manifests, and on-call schedules — each tagged with its source and fetch time. A metrics dashboard's five-minute lag and a deploy webhook's instant fire are not the same clock, so ingestion normalizes both before anything gets compared. Nothing is pulled harder than its source tolerates — periodic snapshots plus debounced webhooks, the same single-pull-cadence discipline that governs every live feed on this platform.

  • Deploys & releasesEvery deploy event, its commit range, the service and environment touched, and who approved it.
  • Incidents & alertsAlert fires, assigned severity, the acknowledging on-call engineer, and the incident ticket it opened or joined.
  • Pull requests & diffsMerged PR metadata plus the raw diff and blame history — not just the commit message — linked forward to the deploy that shipped it.
  • Dependency manifestsLockfiles and manifests snapshotted per build, giving each deploy a real point-in-time bill of materials instead of a periodic best-effort scan.
  • Service topology & ownershipDeclared dependencies between services, queues, and datastores, resolved to the team and on-call rotation that owns each node.
  • SLO & error-budget stateBurn-rate snapshots per service, captured on the same cadence its metric source allows.
Graph

The outage is rarely on the paged service

A service graph turns "payments-api is slow" into a traversal: which deploy or pull request touched payments-api or anything it calls, which shared datastore or queue sits underneath it, and which other services — or other teams' releases — lean on that same resource. Multi-hop reasoning is what surfaces a connection-pool exhaustion two hops downstream, or a vulnerable package three dependency hops down a shared library nobody explicitly owns. Every edge carries the source it was declared or observed from, so a stale architecture diagram never gets treated as ground truth.

  • Deploy-to-incident edgesDirect links from a deploy, config change, or merged PR to every incident opened in the following window.
  • Service dependency edgesDeclared service-manifest dependencies and observed traffic-based calls between services, kept as separate, separately-sourced edges.
  • Package dependency edgesDirect and transitive dependency edges down the software dependency tree, so a vulnerable package two or three layers down still surfaces on every service that ships it.
  • Shared-resource edgesDatastores, queues, and caches with more than one service attached — the classic hidden blast-radius node.
  • Ownership edgesWhich team, on-call rotation, and reviewer pool a given service, repo, or pipeline resolves to.
  • Cross-team blocking edgesA pending change on one team's service that another team's release depends on, visible as a graph edge before either team opens a status thread.
Triage

Ranked candidates, never an autonomous fix

When an SLO starts burning, a PR opens against a fragile service, or a ticket blocks another team's release, the agent walks the graph outward — every deploy, dependency, and change inside the relevant window — and returns a ranked list of candidates, scored by graph proximity, prior correlation strength, and blast radius, with the specific diff, CVE, or blocking edge cited for each. That ranked list is a triage aid on a human's screen, never an executed action — a rollback, a merge, a reprioritization, or a page only fires after a named human confirms it, the same confirm-first gate that governs every execution on this platform.

  • Change-window scanEvery deploy, flag flip, config change, and merged PR inside a configurable lookback window before the alert fired or the ticket opened.
  • Correlation scoreGraph proximity to the affected service plus prior incidents where a similar change preceded a similar symptom.
  • CVE exposure & reachabilityEvery dependency's known vulnerabilities weighted by whether the vulnerable code path is actually reachable from the service, not just present in the tree.
  • Diff-grounded review flagA suggested review comment citing the specific lines and the specific dependency, ownership, or churn fact that triggered it, for a human to accept or dismiss before merge.
  • Cross-team blocker routingA pending change the graph shows is blocking another team's release, proposed for reprioritization with the blocking edge cited, not asserted.
  • Suggested mitigationA specific named action — revert commit X, scale service Y, merge PR Z — queued for a human to confirm, never fired on its own.
Grade

No hit rate before the record closes

A ranking earns a grade only once the underlying incident, deploy, or ticket actually closes: a confirmed root cause in a closed postmortem, a merged fix that did or didn't recur, a blocker ticket that did or didn't actually unblock the release it was flagged for. A suggestion nobody confirmed is excluded from the record, not counted as a hit by default, and a candidate that gets overridden — or turns out correlated but not causal — counts against the score exactly as hard as one that gets confirmed.

  • Closed-record matchWhether the top-ranked candidate matches what the closed postmortem, merged fix, or shipped release actually confirmed.
  • Time-to-correlationHow long after the alert, PR, or ticket opened the correct candidate entered the ranked list.
  • Override & false-positive rateHow often a human rejected the top-ranked candidate, and whether acting on it anyway would have caused harm — a second outage, a wasted review cycle, a needless hold.
  • Unconfirmed proposals excludedA ranking, page, or reprioritization a human never confirmed is dropped from the record, never counted toward the win rate by default.
  • Outcome recoverySLO burn-rate trend, change-failure rate, or release timeline after the confirmed action, tied back to the specific incident, PR, or ticket it addressed.
  • Metered feedback loopConfirmed outcomes feed back into per-service correlation weights for the next ranking, and every LLM call behind the score is metered back to the team it served.
Direction, not roadmap

The three products this becomes.

Sequenced the same way as every other domain: prove the workspace on read-only triage before anything approaches a merge queue or a rollback button. No dates, because there aren't any yet.

On-Call Copilot
A ranked-candidate feed layered on existing paging tools, surfacing the graph-correlated deploy, dependency, or config change directly in the incident channel. Confirm-first end to end — never an automatic rollback.
PR Review Copilot
Diff-grounded review comments that cite the specific CVE, ownership gap, or churn-versus-incident fact behind each flag, posted for a human reviewer to accept, edit, or dismiss. Never an auto-merge.
Cross-Team Release Gate
Checks a pending release against the live dependency graph and flags any unresolved cross-team blocker before the gate opens, for a release manager to confirm or override. The blocking edge is always cited, never asserted.

Adjacent from here: security operations (the same shape — provenance, blast radius, confirm-first) and IT service management — the same rails, a different ticket queue.

Triage that survives the postmortem.

If you're building incident tooling, code-risk intelligence, or evaluating what governed AI actually takes in a production environment — I'd like to hear about it.