The real, in-process logical runtimes this server is composed of — the SynDB engine, SynDrive, SynAuth, SynVault, SynCompute, SynOpt, SynNet, SynStream and SynPost. Each card is probed live: the latency is a real method call or SQL round-trip against the running subsystem, and the metric is counted from it. Health, transitions and last-known posture are persisted in the control plane and survive a restart.

Isolation boundaries with hard resource quotas. Each tenant pins CPU / RAM / storage / GPU ceilings, an isolation mode (container / microVM / namespace) and a workload cap. Live usage is tracked against quota so over-subscription surfaces immediately.

Servers participating in the mini-cloud. Each node advertises its role, CPU / RAM / GPU capacity, agent version and live heartbeat. New nodes are normally added via Settings → Enroll node, which mints a token and prints a real install script.

Trusted endpoints and fleet agents that consume platform resources. Track ownership, trust level, posture and last-seen freshness.

Deployable compute units (web / worker / job / function / media / static). Scale, suspend, wake, restart or roll back any workload — the canonical "run only when needed" control. Each workload is backed by its own SynVault secret namespace.

The live OS-level process table across every node. Suspend, resume, throttle, restart or kill any process in place — the actions a platform operator needs during an incident. CPU / RAM / restarts / open files are tracked per process.

Container runtime instances. Track image, owning tenant, host node, exposed ports, CPU / RAM and restart counts.

Micro-VM and legacy VM workloads for strong isolation or unmodified guests. Track guest OS, vCPU / RAM / disk allocation and isolation mode.

Real, isolated, multi-language functions — the AWS Lambda / Supabase / GCP Cloud Functions equivalent. Author a function in any runtime your nodes support, declare its environment variables and SynVault secrets, then invoke it with a JSON payload to run the code in a scrubbed subprocess sandbox with a hard wall-clock timeout. Every invocation captures real stdout / stderr, updates the rolling p95 and is journaled for audit.

Background job queues and their workers. Track queue depth, processing rate, worker count and drain state — the backbone of asynchronous workloads.

Cron and event schedules plus a live placement simulator. The simulator scores every node for a candidate workload by free CPU + free RAM, honouring role and GPU requirements and penalising degraded nodes — exactly the decision the scheduler makes.

GPU pool inventory and allocation. Track model, VRAM, host node, utilisation, temperature and the workload each accelerator is assigned to.

The custom application packager. Detect a runtime profile from any language or framework, then run the full eight-stage pipeline (detect → dependencies → build → test → SBOM → scan → sign → publish) to produce a signed, attested artifact.

DevSecOps deployments. Deploy an application to provision (or patch) its workload, attach a dedicated SynVault secret namespace and mint a scoped runtime token, then advance the release through its full lifecycle (build → scan → sign → stage → health → approval → production → traffic shift → monitor → stable) with blue-green / canary / rolling strategies and one-click rollback.

The SRE surface, living inside the compute domain. Real, measured signals fused from the live process, SynOpt's tiered memory virtualisation, the work scheduler, the SynOpt↔SynCompute autoscaler and the instrumented IPC fabric — nothing here is synthesised. The autoscaler reconciles on a 15-second cadence; Force reconcile runs a cycle immediately and shows the decision.

Request-to-resource lifecycle tracing — the killer feature. Trace any request end to end and see exactly where time and resources go: DNS → firewall → TLS → proxy → auth → service → SynDB query → storage → response. The dominant bottleneck, CPU-ms, RAM, payload sizes and a risk grade are computed for every trace.

The resource optimizer scans workloads and processes for idle, over-allocated and leaking resources and produces actionable findings with concrete recommendations. Run a scan, then act on (or dismiss) each finding.

Incident and anomaly detection. The scanner inspects the process table, node health and function error rates for CPU exhaustion, crash loops, memory leaks, degraded nodes and error spikes, then opens deduplicated incidents you can triage and resolve.

Durable, queryable operational log for every action taken through the compute control plane — lifecycle changes, deployments, heal events, chaos drills, scans and vault operations. This tier is append-only and survives restart, independent of the live state document, with bounded retention.

The automation engine. Define triggered or scheduled jobs and run them on demand. Bound executors actually run: incident.scan, optimize, health.check, config.snapshot, scale_workload and scale_to_zero.

Plane-wide operations: enroll new nodes, sweep cluster health, version the entire desired-state and review the subsystems behind the control plane.

Generate an enrollment to see the token and the install script.