MOBIRAN
·
Back to products
Data Infrastructure

ARStudio

v1.0.0GA

PostgreSQL fleet console

Centralised monitoring, alerting and SQL editor across PostgreSQL clusters. Per-instance and cluster-level RBAC.

Request Access Read all products
Problem

What this product solves.

PostgreSQL is the backbone of regulated estates — and yet most teams operate their fleet through a patchwork of pgAdmin tabs, ad-hoc psql sessions, Slack-shared SQL files and a couple of scripts that page someone at 03:00. ARStudio replaces that patchwork with a single fleet console: cluster discovery, alert rules, an embedded SQL editor, and per-instance RBAC — all on top of your own PostgreSQL, with the same identity model as the rest of the platform.

Core capabilities

What the product does.

cap_01

Cluster discovery and registration

Register any PostgreSQL 12+ cluster — managed by ARCloud, hosted bare-metal or running on a vendor cloud — and the platform pulls metrics, version, replication topology and size into one view.

cap_02

Real-time metrics

Connections, transactions, replication lag, cache hit rate, bloat. Push-based pipeline, WebSocket streaming to the console. The same data alert rules trigger on.

cap_03

Alert rules and email notifications

Rule-based alerting per cluster, per instance or per role. Email notifications by default; webhook output is on the roadmap. Every alert carries operator, timestamp and the offending metric.

cap_04

Embedded SQL editor

CodeMirror-based SQL surface with syntax highlighting and result tables. Queries are tied to your ARStudio identity — every execution lands in the audit log.

cap_05

Per-instance and cluster-level RBAC

Operators see only the clusters they own. DBAs get edit rights on configuration; analysts get read-only SQL. Same identity model used by ARCloud, ARStreams and ARFlow.

cap_06

Configuration audit

Postgres parameters are tracked over time. Drift surfaces immediately — operators see what changed, when, and by whom.

cap_07

Single console, many instances

No agent per instance. ARStudio observes from outside through the standard PostgreSQL surface. Adding a cluster takes one registration; removing one takes one click.

Operator surface

What operators actually see.

Captured from a live evaluation environment. Same UI customers run; nothing reproduced from a brochure.

shot_01

PostgreSQL instances grouped by cluster — connections, TPS, cache hit, online/offline state per instance.

ARStudio — instances
shot_02

Live alert feed — replication lag, connection saturation and disk pressure surfaced before they page anyone.

ARStudio — alert feed
shot_03

Embedded SQL editor — ad-hoc queries against any registered cluster; credentials never leave ARStudio.

ARStudio — SQL editor
Architecture

How it is built.

ARStudio is a Spring Boot service with a React + CodeMirror frontend, JWT-secured REST and WebSocket APIs, and its own PostgreSQL for metadata. It connects out to the clusters it observes — there is no agent installed on the database hosts. Spring Mail handles email notifications; nothing else is wired to external services by default.

arch_01

Agentless observation

All metrics and configuration come from the standard PostgreSQL surface (catalog views, pg_stat_*). No probes on database hosts.

arch_02

PostgreSQL-resident state

Cluster registrations, alert rules, notification history and audit live in the ARStudio metadata database — kept separate from the databases it monitors.

arch_03

Real-time WebSocket surface

STOMP-over-WebSocket pushes metrics and run state to the React console. Same protocol as ARCloud and ARStreams.

arch_04

Embedded SQL editor

CodeMirror with PostgreSQL grammar. Queries dispatched server-side under the operator’s identity; results paged back through the same channel.

arch_05

JWT + cluster-level RBAC

Identity tokens issued by ARStudio carry cluster and role bindings. Every API call resolves against those bindings before touching a connection.

arch_06

Spring Mail for notifications

SMTP-only by default. Webhook output is on the roadmap; both will share the same notification pipeline.

REST API

Driven by a real REST surface.

Every product action available in the UI is reachable through a JWT-secured REST API. The control plane is the API; the UI is one of its consumers.

api_01JWT

Register a cluster

Adds a PostgreSQL cluster to ARStudio. Connection string and read-only credentials only.

POST/api/v1/clusters
Response
{
  "id": "cluster_billing_prod",
  "state": "registered",
  "primary": "pg-billing-01",
  "replicas": ["pg-billing-02", "pg-billing-03"]
}
api_02JWT

Active alerts across the fleet

Live alerts grouped by cluster, with rule, severity and first-seen timestamp.

GET/api/v1/alerts?state=active
Response
[
  {
    "cluster": "cluster_billing_prod",
    "rule": "replication_lag_high",
    "severity": "warn",
    "since": "2026-05-17T07:42:19Z"
  }
]
api_03JWT

Cluster health summary

WAL position, lag, connections, query duration buckets — same surface as the dashboard.

GET/api/v1/clusters/{id}/health
Operator CLI

Operated from the terminal too.

The `arctl` CLI talks to the same control plane as the UI. Same primitives, scriptable, suitable for CI and on-call.

cli_01arctl

Register a cluster

One command, declarative; safe to commit a registry of clusters to git.

arctl studio cluster register -f clusters/billing-prod.yaml
cli_02arctl

Active alerts across the fleet

Filterable by severity and cluster. Same surface as the alerts page.

arctl studio alerts list --state=active --severity=warn,critical
Output
CLUSTER                 RULE                       SEVERITY  SINCE
cluster_billing_prod    replication_lag_high       warn      4m
cluster_orders_prod     connections_near_max       warn      18m
cli_03arctl

Run a saved SQL snippet

Operator-grade ad-hoc queries against a registered cluster — credentials stay in ARStudio.

arctl studio sql run --cluster=cluster_billing_prod --snippet=slow-queries
Integrations

What it connects to.

integration

PostgreSQL 12+

Any cluster reachable on its standard port. Logical replication topology, streaming replication, vanilla Postgres — all supported through catalog introspection.

integration

ARCloud

Managed PostgreSQL clusters provisioned through ARCloud appear in ARStudio automatically once the tenant grants visibility.

integration

ARStreams

Streams running through ARStreams expose their LSN and lag in ARStudio dashboards — replication health visible alongside the source cluster metrics.

integration

ARFlow

ETL runs scheduled through ARFlow surface their source/target connection counts and write throughput in ARStudio. Same identity gates the view.

integration

SMTP

Email notifications via Spring Mail. Plug in your enterprise SMTP — TLS, auth, sender impersonation all supported.

integration

Identity provider (roadmap)

JWT today; SAML / OIDC federation is the planned next step. The cluster/role binding model already aligns with external IdP claims.

Use cases

Where it runs in production.

  1. case_01

    Banking PostgreSQL fleet

    Tens of clusters across regions watched from one console. Alert rules differentiate production / staging / DR; audit captures every config change for the regulator.

  2. case_02

    Government DBA practice

    A central DBA team operates sovereign PostgreSQL estates for multiple ministries. Cluster-level RBAC keeps tenants apart while one team enforces policy.

  3. case_03

    Migration cockpit

    During a migration from a commercial DBMS, ARStudio is the single pane on both source and target Postgres clusters — replication lag, configuration drift, capacity headroom.

  4. case_04

    Ad-hoc analytics gating

    Analysts run SQL against read replicas through the audited editor instead of via personal psql sessions. The audit log answers the "who ran what" question for compliance.

  5. case_05

    Pre-production guard rail

    Configuration audit catches accidental drift between staging and production. Alert rules fire on deviation, not just on outage.

Deployment

How it is operated.

ARStudio ships as a Spring Boot JAR with a React control surface. Runs on a single VM or container. The metadata PostgreSQL is small and lives on the same host or alongside it. The platform only needs outbound TCP to the clusters it observes.

  • Single JAR, systemd unit, optional nginx reverse-proxy.
  • Read-only network reach to each registered cluster is sufficient.
  • SMTP gateway for email notifications (optional).
  • Air-gap-ready: no outbound calls beyond your perimeter; no SaaS dependency.
  • Scales to fleets of dozens of clusters from a single control instance.
Core capabilities

Evaluate this product.

Open the workspace if you already hold credentials, or request guided access through the briefing flow.

Request Access Read all productsRead the docs