When does temBoard beat a general metrics-and-dashboards stack, and when does it lose, for a two-person DBA team running 40 PostgreSQL instances for a public-library network?
answer
- watching vs acting
- PostgreSQL views with no dashboard building
- fixed checks, email or SMS
- metrics endpoint behind an API key
- superuser agent on every host
basics
~20 stemBoard wins when a small team wants a ready-made PostgreSQL console where it can also act: terminate sessions, change settings, schedule maintenance. A metrics stack wins on custom alert rules, routing, long-term analysis and anything beyond PostgreSQL.
solid answer
~40 sFor two DBAs and 40 instances, temBoard gives PostgreSQL-shaped pages on day one: per-instance dashboards, the activity view with Terminate, configuration editing, scheduled VACUUM and ANALYZE, `pg_stat_statements` history, and built-in checks with warning and critical thresholds that email or text you. Nobody builds dashboards, and Environments control who may act. A general metrics stack wins when you need **custom alert expressions with routing, silencing and escalation**, application and host metrics in the same place, flexible queries over long history, or instances where you cannot install a superuser agent on the host. It is not either-or: since 8.0 the UI exposes each agent's metrics in OpenMetrics format through an authenticated proxy with an API key. Also weigh that temBoard 10 is maintained but slow-moving.
code
ini · 20 lines# /etc/temboard/temboard.conf on the central console host
[temboard]
port = 8888
cookie_secret = <long random string>
[auth]
# hosts allowed to use API keys, e.g. the metrics scraper
allowed_ip = 10.20.0.15/32
[notifications]
smtp_host = mail.library.example
smtp_port = 587
smtp_tls = True
smtp_from_addr = [email protected]
[monitoring]
purge_after = 400
[statements]
purge_after = 30go deeper
Know that temBoard is a PostgreSQL-only console where you can also act, while a metrics stack watches many kinds of systems.
Explain what each side does well: ready-made pages and actions versus custom queries, alert rules and breadth, and that temBoard alerts on fixed checks.
Recommend for a concrete fleet: start with temBoard or keep it as the action console beside an existing stack, scrape it through the UI proxy, and harden the superuser agents.
Frame the long-term bet: a niche, slow-moving tool that saves a small team effort now, against platform consolidation, managed-service plans and security review of agents.
## Two different tools A **general metrics stack** is a time-series database that scrapes exporters, a dashboard layer, and an alerting layer that evaluates rules and routes notifications. It is built for any system, so PostgreSQL is one more target you model yourself. **temBoard** is a PostgreSQL-only console: a UI and repository plus a superuser agent beside each instance. The real question is not which draws better graphs but whether the team mostly needs to **watch** or also to **act**. ## Where temBoard wins - **No dashboard building.** Dashboards, activity, configuration, maintenance and statements pages exist the moment an agent is registered; for two people covering 40 instances that is weeks saved. - **Seeing and acting in one place.** The Activity page terminates a blocking session; the configuration page runs `ALTER SYSTEM` and reloads; the maintenance page schedules `VACUUM`, `ANALYZE` or `REINDEX`. A metrics stack shows the problem and leaves you to open a SQL client. - **Host-level detail per backend.** The agent reads `/proc` for each backend's CPU, memory and I/O, something a remote exporter cannot see. - **Built-in, sensible checks.** Alerting ships with checks such as `sessions_usage` (80/90 %), `waiting_sessions_db` (5/10), `wal_files_archive` (10/20), `fs_usage_mountpoint` (80/90 %) and `hitreadratio_db` (warning below 90 %, critical below 80 %), each with per-instance thresholds you can edit, and email or SMS on a state change. - **Access by Environment.** Each instance sits in one Environment, whose members may manage it, which suits splitting branch databases from central services. ## Where a metrics stack wins - **Alert logic.** temBoard evaluates a fixed list of checks against two thresholds. It has no rule language, no grouping or deduplication across the fleet, no silencing windows, and no escalation to an on-call rotation. - **Breadth.** Applications, load balancers, the library's web catalogue and the database host's network all live in one place; temBoard sees PostgreSQL and basic host metrics only. - **Analysis over time.** Arbitrary queries and joins across metrics and long ranges. temBoard keeps aggregated history (730 days by default) and statement history (7 days by default) for its own charts. - **Where no agent can go.** On a managed service with no shell on the host, temBoard cannot run at all. - **Momentum.** temBoard 10.0.0 shipped in December 2025 and the project is maintained but slow; a general stack has a far larger ecosystem. ## Side by side | Need | temBoard 10 | General metrics stack | |---|---|---| | PostgreSQL pages without setup | yes | build or import dashboards | | Terminate a session, change a setting, schedule maintenance | yes, in the UI | no, use a SQL client | | Custom alert rules, routing, silencing | no, fixed checks | yes | | Non-PostgreSQL metrics | basic host metrics only | yes | | Install on the database host | superuser agent required | exporter optional, often remote | ## Using both Since 8.0 the UI can act as an **authenticated proxy** to each agent's metrics endpoint, which serves OpenMetrics text, a subset of the usual node and PostgreSQL exporter metrics plus temBoard's own. Create an API key with `temboard apikey create`, and restrict who may use API keys with `[auth] allowed_ip` (only `127.0.0.0/8` by default). The agent's endpoint itself sits behind request signing, so scrapers go through the UI's `/proxy/<address>/<port>/monitoring/metrics` route. Expect gaps if you import ready-made dashboards: temBoard exposes only a subset of the metric names those dashboards assume, plus its own metrics prefixed with `x`, such as `xpg_wal_files_bytes_total`, so some panels stay empty. A pragmatic split is to scrape temBoard for the PostgreSQL series the stack lacks, keep alert rules in the stack, and leave the actions where only temBoard can do them. That way the on-call path runs through one alerting system, while the two DBAs still open temBoard when an alert sends them to a specific instance. ## A recommendation for the library network 1. If the team has no metrics stack today, start with temBoard: one UI, one repository database, 40 agents, Environments such as branches and central services, and email notifications for the built-in checks. 2. If an organisation-wide stack already exists, keep alert routing and long-term analysis there, scrape temBoard through its proxy if useful, and use temBoard as the DBAs' **action console**. 3. Either way, harden it: change the default `admin` password, set `cookie_secret`, replace self-signed certificates, firewall agent ports to the UI host, and remember that every agent is a superuser on its instance. 4. Revisit the choice if instances move to a managed service, where the agent cannot be installed.
- Can an existing time-series system scrape temBoard agents directly on port 2345?Not usefully. The agent's metrics route sits behind the same request signing as the rest of its API, which only the UI can produce. Scrape through the UI's proxy route with a temBoard API key instead, and allow the scraper's address in [auth] allowed_ip, which defaults to 127.0.0.0/8 only.
- What does temBoard's alerting send, and what must be set before anyone receives it?It sends an email over SMTP or an SMS when a check on an instance changes state. Three things must be set: the [notifications] transport in temboard.conf, an email address or phone number on each user, and notifications switched on for the instance. Thresholds are edited per instance.
- What security cost does temBoard add that a remote exporter does not?Every monitored host runs a superuser agent with an HTTPS API that can terminate sessions, change settings and run maintenance. Requests must be signed by the UI's key, but anyone controlling the UI controls the fleet, so the UI's admin account, cookie secret, certificates and the agents' network exposure all need hardening.
- temBoard's alerting supports custom rule expressions with routing and silencing.
- temBoard can monitor a managed PostgreSQL service where you have no shell on the host.
- Using temBoard rules out a metrics stack, because it exposes no metrics in a standard format.
- temBoard keeps statement history for two years by default, like its monitoring charts.
- temBoard is a fast-moving project with frequent major releases.
Assumes temBoard 10.0.0 (December 2025): PostgreSQL 13 to 18, distribution packages only, maintained but slow-moving.