• Get started

    • Getting started
    • Concepts
    • Tour
  • Using shpyrd

    • Deploying
    • shpyrd.yaml
    • Resources
    • Databases and caches
    • Domains and exposure
    • Sign-in for your app
    • Teams, roles and security
    • AI assistants (MCP)
    • Logs
    • Dashboard
    • CLI reference
  • Running it yourself

    • Installation
    • Oracle Cloud (OKE)
    • AWS (EKS)
    • Extensions and sign-in
    • Platform backups
    • Architecture guide
  • Project

    • Design principles
    • Roadmap
    • How to contribute
    • Support the project
  1. Using shpyrd
  2. Dashboard
Sign in
Start free

Dashboard

The web UI - the launcher, a project's pages, the workspace's pages, and the console where the operator runs the platform.

The dashboard is your workspace's address: on shpyrd cloud, https://<workspace>.shpyrd.cloud, such as https://acme.shpyrd.cloud; on a cluster you run yourself, https://<domain>. Everything the CLI does for projects can be done there, and it is the place to watch what is happening. On a cluster you run yourself, the operator also has the console, at https://shpyrd.<domain>.

Signing in

On shpyrd cloud you sign in at your workspace's address with your account, or with your company's sign-in once the workspace has one (People, teams, roles and security). The menu under your name says how you signed in and has Sign out.

Self-hosted

shpyrd cluster dashboard opens the console signed in through a one-time ticket; the login pages also accept the admin token pasted by hand (shpyrd cluster token). Sign-in redirects to the allowed IdP, or to Dex for operator-configured OSS credentials. Account recovery, MFA and passkeys belong to Accounts or the customer IdP. See Extensions and sign-in.

The launcher

Everyone lands on the launcher after signing in: a card for every app they may open (public apps included), sorted by name. Each card has the app's icon, its one-line description, who may open it (Anyone for a public app, Everyone when the everyone team has access, else its teams by name), whether it is internal, and the address it opens: its own domain once that domain answers, else its address under the workspace.

People who build open a project from the settings button on its card. The + button (New project) creates one: a slug, a name, a line of description, the network (public internet or internal, where the workspace has private networking), and optionally a Git repository to build and release right away. Where the server reads a catalog, the + is a menu: an empty project, one from GitHub, or one from templates, the catalog. The gear opens the workspace's pages (owners and admins). People whose only roles are user or reader see the cards and nothing else.

The catalog

The catalog lists applications ready to run in the workspace: agents, CRMs, open-source projects. Each entry says where its code lives, how it runs and what it asks at install. Pick one, by category or by a word; its page shows what it needs (a key to type, a disk, a database) and the install form: the project's slug and name, the entry's inputs, and whether the project follows the entry's branch, so every new commit upstream is built and released, or pins a tag. Installing makes the project, its disks and resources, sets the inputs as config vars, and starts the first build; from then on it is a project like any other. The entries come from a repository of entry folders, published as an index the server reads; see Deploying.

A project's name, description and icon are set from the pencil next to its name (or shpyrd projects describe): a symbol in one of 14 colours, or an image of its own, an SVG drawn in the colour or a PNG or WebP shown as it is. The workspace's Name and look (Workspace › General) puts your logo and accent colour on the launcher, the header and the login page. See Sign-in for your app.

A project

A project's header has its name and slug, its phase (Maintenance while its page is up), the network badge (public internet or local network; developers and admins click it to switch front doors where private networking is on), a lock badge when visitors sign in, and the actions: Open, Deploy (from Git, with buildpacks or a Dockerfile; its menu also has Redeploy the current release, or Build the same source again after a failed build, and Rebuild from the source) and the trash icon to destroy the project (you type its slug to confirm).

Under the header, only while something is happening: the build's output as it prints; the release command's output, with Run it again when it failed; the rollout per process ("web 1/3 on the new release, 3 serving"); why the build failed or the release is not healthy; or that the maintenance page is up, since when and by whom, with Serve the app again.

The pages are in a list at the side:

  • Overview: the Summary (source, build strategy, current release and build, each process' size and count), Maintenance (developers and admins: the switch that puts a page in front of the app, and what it says; see Maintenance mode) and the latest Activity.
  • Run
    • Releases: the releases (what changed, build number, Rollback) and the Builds (status, strategy, source, duration; open one to read its output, live while building).
    • Backups (admins): back the project up to a file and restore it.
    • Metrics: see below.
    • Logs: every instance streamed live, named web.1, worker.2. Pick a process and a minimum level, filter by text, switch Live off to pause, Raw to see lines as written. See Logs.
    • Shell (developers and admins): a shell in a running instance.
  • Configure
    • Config: Config vars, by name; set, replace, remove, or Set from a .env. Values are never shown. Variables of attached resources are listed read-only. Plain environment shows what every process sees besides them.
    • Resources: Processes (size and number of instances of each, applied together in one release; the web row says when the app sleeps and a Sleep button sets it) and Beside the application (databases, caches, buckets and volumes: create, resize, snapshots, a bucket's key, when a dedicated database sleeps).
    • Domains: the project's own domains, with the exact DNS record to create and each one's DNS and certificate state. See Domains and exposure.
    • Drains: the project's log drains and their delivery status.
  • Access
    • Access: Who may open it and Open as. See below.
    • Roles (admins): who holds reader, user, viewer, developer or admin, people and teams.
    • Connections: which other projects, and which platform callers, may reach this one inside the cluster.
    • Activity: the audit trail.

Actions that would start another release are disabled while one is building or rolling out, and everything a role cannot do is hidden or disabled (People, teams, roles and security).

Metrics

Modelled on what Heroku, Fly and Render show for an application:

ChartWhat it shows
Throughputrequests per second at the ingress, stacked by response class (2xx, 3xx, 4xx, 5xx)
Response timep50, p95 and p99 latency at the ingress
Instancesrunning instances per process type (step chart)
CPUusage by process, in cores against a line at what the process was given, or as a share of it
Memoryworking set by process, in bytes against the same line, or as a share of it; every out-of-memory kill is marked
Networktraffic in and out

Dashed lines mark releases. Ranges: last 15 minutes, hour, 6 hours, 24 hours, 7 days. What a process was given is its instance size times its instances; shared sizes can read above it while bursting.

The controls above the charts narrow them: one process or every process; by process or by instance (web.1, web.2…), which only CPU, memory and network can do, since throughput and latency are measured at the edge; for instances, each one, their sum, the average or the busiest; cores and bytes, or a share of the size; and whether the instances replaced during the range are shown, as replaced 1, replaced 2… The CLI takes the same choices (shpyrd metrics).

Access

The project's Access page says who may open the app in the Who may open it card: Anyone (public), Who signs in (sign-in required) or Named people (public, signed-in visitors identified). Project admins change it; making an app public asks for confirmation, and a badge says "Anyone on the internet may open it" while it is. Open as (developers and admins) opens the app in a new tab as the teams of your choice, or as nobody, so builders see what their users see; Open as myself ends the preview. See Sign-in for your app.

Workspace

Every project, team and person belongs to the workspace. Its pages are in a list at the side:

  • General: the name, the Name and look (name, accent colour, logo) and, where the workspace has one, its Plan: a bar per ceiling (projects, instances, CPU, memory, block storage, object storage, buckets, databases) and a line on what the plan includes. A change that would go over is refused with the number; what is already over keeps working and nothing more fits there. Administrators also set Caps per project there: a project with a cap claims no more block storage than it says, below the workspace's; the project's Overview shows its storage against whichever applies.
  • Access
    • People (owners and admins): the people with their workspace role (owner, admin, member; only owners name owners), the method they signed in with, when they were last seen, Suspend and Let back in, and the Invite dialog, whose link is shown once and emailed when the platform sends mail, with the pending Invitations below.
    • Teams (owners and admins): the teams projects grant roles to.
    • Sign-in (owners and admins): the sign-in methods (Google, Microsoft, GitHub, any OpenID Connect provider), Who may join on first sign-in, and the Company domains.
    • API tokens: your tokens, and the session tokens of your CLI logins.
    • Connections (with the MCP server): the assistants and pipelines connected to the workspace.
  • Platform
    • Config vars (owners and admins): config vars every project receives.
    • Log drains (owners and admins): drains for every project's lines.
    • Domains (owners): the workspace's address and its custom domains. See Domains and exposure.
    • Application (owners and admins): what answers at the workspace's address, the platform's own workspace application or one of the workspace's own, and the Registry credentials it is pulled with. See Your own workspace application.
    • MCP (with the MCP server): the name and address assistants use.

See People, teams, roles and security.

Your own workspace application

The workspace application (the launcher, a project's pages, the workspace's pages) is a static build the server serves at the workspace's address. A workspace may serve a build of its own instead: a fork of the platform's apps/workspace, built with next build and published to a registry of yours, GHCR, Docker Hub or any other, as an artifact (oras push ghcr.io/acme/workspace-ui:2.3.1 out/) or as an image (FROM scratch + COPY out/ /). It talks to the same API, from the same origin, with the same session; it gains nothing the platform's own does not have, and every call is checked by the server as before. The platform's own registry is not involved.

Under Workspace › Application, an administrator pastes the reference, oci://ghcr.io/acme/workspace-ui:2.3.1 or @sha256:…, and the door serves it from the next request. A tag is settled to the digest it points at at that moment, so what the door serves never changes until someone sets it again; publishing a new version changes nothing by itself. The page says how the application is doing on the server answering: serving, with the name and version its shpyrd-app.json declares; not served, with the reason; or not allowed on this server. Whenever the application cannot be served, the platform's own answers, so nobody is locked out, and Back to the platform's own is always there. Load again reloads it on the next request.

A private repository needs a read-only credential for its registry host, one per host, under Registry credentials: a GitHub token with read:packages for ghcr.io, an access token on Docker Hub. Values are written, never shown. Setting a reference whose registry refuses the pull, or whose package is not one (no index.html at the root, over 64 MB or 4000 files), is refused there and then with the registry's words.

The package may carry a shpyrd-app.json at its root: {"name": "Acme", "version": "2.3.1", "origins": ["https://cdn.acme.test"]}. The origins are the only places beyond the server its pages may load scripts from, connect to or show images from; without the file, none.

The operator chooses which sources a server accepts with SHPYRD_UI_SOURCES: oci by default; oci,dir where the server runs for development, so dir:/path/to/out serves a build straight from its folder; off keeps the references but serves the platform's own everywhere. The CLI: shpyrd workspace ui set|clear|reload and shpyrd registry-auth set|unset|list. The example to start from is shpyrd-example-workspace-app.

The console

Self-hosted: on a cluster you run yourself, the operator has the console at https://shpyrd.<domain>; on shpyrd cloud, we run it. Its users are its own list (Console users), apart from every workspace's people. Its pages:

  • Overview: the cluster as installed (environment, version, domain, the public and private front doors) and its Capacity: CPU and memory used (what the machines are doing) versus reserved (what running processes asked for, which limits scheduling), over the last hour, 6 hours, 24 hours or 7 days.
  • Platform: Workspace (a link to the workspace), Console users, Accounts (with auth-local), Sign-in (the platform's methods), Costs and Cost drains (with the costs extension), and Settings (the workspace's limits and sleep defaults, and the license).
  • Cluster: Instances (the size catalog, in three lists with the same names: processes, Postgres and Redis; add, change, delete sizes and pick each list's default), Placement (where each project's processes and data run), Registry (mode, health, storage, images, certificate, garbage collection with Collect now), Storage (with object-storage), Backups (the platform backups and their archives), Email (with mail; the sender's status and a test message) and Components (the extensions with their state, the installed components with versions, and the Helm releases).

Cluster-wide log drains have no page: the operator adds them with shpyrd drains add --cluster (Logs).

Security notes

  • Every /api route needs a signed-in session or a token, except the health check, the public configuration and the content-addressed source archives fetched by build pods.
  • Config var values are write-only through the API and the UI.
  • Image references and internal addresses are not exposed on project pages; builds and releases are identified by number and digest. The registry's address appears in the console only.
  • On the local profile the dashboard is only reachable from your machine.

Cluster costs

With the enterprise costs extension, Console → Costs explores a UTC date range of up to 366 days. Project rows show their workspace. Expand a workspace into projects, then applications, databases, builds or storage, then processes and resources. Resource type, resource and provider service are separate grouping choices. Resource details show the complete provider identifier and a copy action.

Project-less costs are classified as System services only when the collector recognizes the system namespace, Idle capacity when OpenCost reports unused capacity, or Unattributed costs when ownership is unknown. Known workspace ownership is retained. Historical records without enough classification evidence remain unattributed.

Filter by workspace and category, or search workspace names, project names and resource identifiers. The table loads 50 groups per page and fetches expanded children on demand. Summary totals cover all matching groups, including other pages. Currencies remain separate; the currency selector controls sorting and percentages without currency conversion. Cost records, shown inside expanded rows, count collection records rather than resources.

Estimated (OpenCost) and Provider-reported cost are independent sources. Data-through and last-successful-collection timestamps show their freshness; missing timestamps stay unknown until a successful collection. Open periods are marked incomplete, and source corrections may arrive after a period ends. Configure the read-only OCI connection under Cost settings.

Export CSV prepares all groups matching the current filters in the background, including groups outside the current page. Download the result when ready. Each currency has a separate CSV row. Exports use a consistent database snapshot, are available for 24 hours, and are accessible only through the licensed console cost routes. At most five exports can be queued; a failed export can be requested again.

Daily database aggregates speed up longer periods without discarding the raw records. The cost explorer migration backfills existing records once; subsequent inserts, corrections and deletions update the aggregates transactionally.

On this page

  • Signing in
  • The launcher
  • The catalog
  • A project
  • Metrics
  • Access
  • Workspace
  • Your own workspace application
  • The console
  • Security notes
  • Cluster costs
Back to top
  • AI Community
  • Vibe Coders
  • Developers
  • Businesses
  • FDEs & Implementation Partners
  • Getting Started
  • Pricing
  • Docs
  • Changelog

© 2026. shpyrd. All rights reserved.LegalTerms of ServicePrivacy Policy