PulseBoard Sign in Sign up

Every signal. Every cloud. One predictable bill.

PulseBoard is a full-stack observability platform: metrics, logs, traces, alerts with built-in on-call, synthetic uptime, public status pages, GitOps-managed dashboards, cost & cardinality killers, and first-class pollers for AWS, Azure and Google Cloud. Self-host the MIT-licensed edge or use the hosted cloud — the math behind your invoice is the same calculator we show on the pricing page.

Start with Basic → Tour the platform Quickstart
30s from curl to first metric MIT-licensed edge runtime 26 panel types 3 hyperscalers, one wiring
PulseBoard dashboard showing CPU, memory, disk and network panels across multiple hosts
Cloud integrations

Pollers for AWS, Azure & Google Cloud — wired in a wizard.

Connect a cloud account in three clicks: launch a CloudFormation stack, paste a role ARN, pick the services you care about. PulseBoard's cloud-poller fans out across regions, scrapes the right APIs at the right cadence, and folds the samples into Prometheus-style series your existing dashboards already understand. No long-lived secrets stored: AWS uses STS+ExternalId, Azure and GCP use Workload Identity Federation against our public OIDC issuer.

Amazon Web Services GA

CloudWatch metrics & logs, CloudTrail, Step Functions waterfall via Firehose, Lambda extension, IAM-scoped onboarding CFN.

Tour the AWS integrations →

Microsoft Azure GA

Azure Monitor metrics across VMs, App Service, AKS, Cosmos, SQL DB, Service Bus and more — via federated workload identity.

Tour the Azure integration →

Google Cloud GA

Cloud Monitoring, Cloud Logging via Pub/Sub, BigQuery cost export, GKE cluster shape, Cloud Run sidecar, Cloud Functions tracer.

Tour the GCP integrations →
Prometheus OpenTelemetry Loki push Kubernetes Docker systemd journald Windows Event Log
The whole platform

One edge runtime, every observability pillar.

Twelve product surfaces, all in the same MIT-licensed binary. No "add-on" pricing, no separate sub-products, no "see a Loom for traces."

Metrics

Live metric pipeline

Prometheus remote_write, OTLP/HTTP, native JSON and Loki push — into a single in-process engine with full PromQL. Optionally delegate to a Mimir backend for long-term storage.

Logs

LogQL-compatible

Loki push API at /loki/api/v1/push; LogQL query_range from the same UI. Label filtering, |= "text", regex line-filters — all in one place as your metrics.

Traces

OTLP traces + service map

OTLP/HTTP at /v1/traces (protobuf or JSON). Per-trace waterfall, automatic service-map edges, error-rate overlays. AWS Step Functions span synthesis via Firehose for serverless waterfalls.

Alerts

Alerts with built-in on-call

Full PromQL rule engine, Alertmanager-compatible routing tree, silences, inhibition, mute windows. Plus a first-class on-call catalog: users, rotations, overrides, multi-step escalations — no extra PagerDuty subscription.

Runbooks

Inline runbooks & MTTR

Attach Markdown step-by-step runbooks to any rule. PulseBoard records step completion and MTTR per fingerprint, with incident analytics that surface your most-skipped steps.

Synthetics

Synthetic uptime

HTTP, TCP and DNS probes from one or more regions. Results land as a real pulse_synthetic_up{} series so they compose with your other metrics, alerts and status pages.

Status pages

Public status pages

Branded /status/<slug> pages backed by live thresholds and synthetic probes. Component up/down, incident timeline, configurable uptime window — no extra service to run.

Dashboards

26-panel dashboard library

Timeseries, stat, gauge, table, logs, traces, flamegraph, nodegraph, heatmap, state-timeline, geomap, candlestick and 14 more. Variables, repeats, dark/light themes, embeddable share links.

Cost

Cost & cardinality killers

Per-team cost attribution in real time. The cardinality killer watches series-per-label-value, blocks the runaway dimension before it hits storage, and tells you exactly which deploy introduced it.

GitOps

GitOps & export-as-code

Point PulseBoard at a Git repo and it reconciles your dashboards and rule groups. Every panel exports to YAML or Terraform HCL via the </> Code button.

AI

In-process spike analysis

"Why did p99 spike?" — answered without sending your samples to OpenAI. A deterministic in-process analyser (mean/stddev/jump) is the default; bring your own LLM via the IAiProvider adapter when you want one.

Multi-tenant

Workspaces, RBAC & SSO

OIDC against any provider, three RBAC scopes (admin/query/ingest), per-workspace isolation, Mimir org-header injection, and audit-friendly access logging on every request.

PulseAgent

One lightweight Rust agent, every collection source.

Install with a one-liner on Linux, a Helm chart on Kubernetes, or as a Windows service. PulseAgent ships host metrics, container logs, Kubernetes pod logs, journald, the Windows Event Log, arbitrary Prometheus scrape targets, and OTLP-from-your-app — to your edge over a single bearer token.

Sources

host_metrics · docker · kubernetes_pods · journald · windows_event_log · prom_scrape · otlp_receiver · file_logs

Processors

batch · relabel · redact_pii (regex PII scrubbing before send) · cardinality_guard · transform

Deploy targets

Linux (systemd) · Windows (service) · macOS (launchd) · Kubernetes DaemonSet · Docker · AWS Lambda extension · GCP Cloud Run sidecar · GKE DaemonSet 

# Linux / macOS one-liner
curl -sSfL https://pulseboard.dev/install.sh | sh

# Windows PowerShell
iwr -useb https://pulseboard.dev/install.ps1 | iex

# Kubernetes
helm repo add pulseboard https://charts.pulseboard.dev
helm install pulseagent pulseboard/pulseagent \
  --set target.url=https://your-edge \
  --set target.token=$PB_KEY

Read the PulseAgent deep-dive →

Why we built it

Three things the incumbents won't do.

Cost transparency

Know what every team is costing you.

Real-time per-series and per-team attribution. Find the runaway label before the invoice arrives. GET /api/admin/tenants/<id>/cost/teams is the same endpoint that drives our pricing calculator.

Cardinality killer

Block runaway dimensions at ingest.

Per-label-value caps, per-team caps, automatic identification of the deploy that introduced the offender. The bad label never reaches storage — your bill doesn't spike, your dashboards don't grind.

Predictable pricing

Flat tiers. Public calculator. No surprises.

The pricing page POSTs to the same endpoint that bills you. What you preview is what you pay — across ingest bytes, active series, trace spans, alert evaluations and seats.

Ingest

Every protocol you already use — no rewriting pipelines.

PulseBoard speaks the open standards. No proprietary SDKs required.

Prometheus remote_write OTLP/HTTP metrics · logs · traces Loki push API LogQL query_range Native JSON ingest NDJSON PulseAgent host + container metrics Docker log scrape Kubernetes pod logs systemd journald Windows Event Log PromQL scrape targets Firehose → Step Functions spans Pub/Sub → Cloud Logging BigQuery → Cloud Billing 
# 1. Get a key (hosted) or run locally
curl -X POST https://your-edge/api/signup \
  -H 'content-type: application/json' \
  -d '{"slug":"acme","email":"you@acme.com"}'

# 2. Push a metric
curl -X POST https://your-edge/ingest/metrics \
  -H "Authorization: Bearer $PB_KEY" \
  -H 'content-type: application/json' \
  -d '[{"name":"payments.latency.p99","value":42.5}]'
# 3. Ask the AI why
curl -X POST https://your-edge/api/ai/explain \
  -H "Authorization: Bearer $PB_KEY" \
  -H 'content-type: application/json' \
  -d '{
    "seriesName": "payments.latency.p99",
    "samples": [
      {"ts":1,"value":1.0},{"ts":2,"value":1.1},
      {"ts":3,"value":9.0},{"ts":4,"value":1.1}
    ]
  }'
# → "Largest single-step jump was 7.90 at index 3 (> 2× stddev)…"
Pricing

Flat tiers. Public calculator. No surprises.

Full breakdown and an interactive calculator on the pricing page. The exact same endpoint that bills you.

Basic

$39/mo
  • 50 GiB ingest · 20 GiB logs
  • 100k active series · 10M spans
  • 3 seats included
  • Backed by 4 shared vCPU workspace
Choose Basic

Pro

$149/mo
  • 250 GiB ingest · 100 GiB logs
  • 500k active series · 50M spans
  • 10 seats · then $5/seat
  • Performance CPU workspace backing
See calculator

Enterprise

Custom
  • Unlimited tiers, contract caps
  • SSO / SCIM / audit export
  • Private LLM adapter for AI assist
  • Self-hosted or dedicated edge
Contact sales
Self-host

Need free? Run the whole stack yourself.

The edge runtime, PulseAgent, the tracer SDKs and every cloud poller integration are MIT-licensed on GitHub. Self-hosting stays free; hosted plans are paid so we can sustainably operate cloud infrastructure.

Docker

docker run -p 8080:8080 \
  -v /data/pulse:/data \
  ghcr.io/pulseboard/pulseboard:latest \
  --port=8080 --data=/data

Kubernetes (Helm)

helm repo add pulseboard https://charts.pulseboard.dev
helm install pulseboard pulseboard/pulseboard \
  --set ingress.host=metrics.acme.com \
  --set mimir.url=http://mimir:9009

Full self-host guide →