Product

How Vesana works.

One server, three ways to get data in, one data path that consolidates everything.

Architecture

One platform.
Three ways to collect data.

An agent on the machine, a collector in the network, or the server probes on its own. Everything ends up in the same database, the same UI.

Agent Windows · Linux

Collector Linux VM

Active the server

Receiver FastAPI · HTTPS Ingest

Redis Stream

Worker ×3 asyncio Pool alert → Notifications

PostgreSQL TimescaleDB · Hypertables

REST API

Frontend React 18 · Vite

Architecture in detail

Three modes

Each mode fits a
different situation.

Vesana treats them all the same: data comes in, gets consolidated, lands in the dashboard. Mix them freely.

01

Agent

On the target system.

When: When you want to measure on the machine itself — CPU, RAM, disk, services, processes, event logs.
What runs: Lightweight single binary in Go. No runtime, no dependencies. Runs on Windows and Linux.
Auth: Token, stored hashed. One token per host.
Transport: HTTPS outbound, no inbound port required.

02

Collector

In your (or your customer’s) network.

When: When you want to monitor devices that can’t or shouldn’t run an agent — switches, firewalls, UPS, NAS, printers.
What runs: Single binary in Go on a Linux VM. SNMP, SSH, ping, HTTP/S — plus anything you upload as a custom script.
Auth: API key, stored hashed. Multiple collectors per tenant.
Transport: HTTPS to the Vesana server. Outbound-only.

03

Active

From the Vesana server itself.

When: When you want to measure something reachable from the server — public APIs, DNS, status endpoints, certificates.
What runs: Directly in the Vesana worker. Scheduled checks, configured in the database.
Auth: None — the server is the source.
Transport: Outbound from the Vesana server to the target.

The data path

What happens after the push.

Every incoming result passes through six stages before it shows up in the dashboard. Here is each one.

01

Receiver

FastAPI endpoint accepts POST requests from agents and collectors, validates auth tokens, persists nothing.
02

Redis Stream

Results land in a stream. Decouples ingest speed from processing speed, keeps the receiver fast.
03

Worker

A Python pool reads from the stream, parses, applies the state machine, writes to the database. Three parallel workers by default.
04

TimescaleDB

PostgreSQL with hypertables for check results and logs. Keeps raw data as long as you configure.
05

API

FastAPI layer enforces tenant_id on every query, applies permissions, answers REST + SSE.
06

Dashboard

React frontend, plus mobile apps. Reads from the API, writes back (ACK, downtime, configuration).

Setup

Three steps, <15 minutes.

Vesana is built as a self-hosted product. There is no cloud edition, so there is no cloud onboarding flow. You install, you start, you use it.

01
Run the installer.

One command as root on a 4 GB VM or your homelab host. It installs Docker if needed, pulls the stack, generates secrets and brings everything up. No Kubernetes required.
```
curl -fsSL https://vesana.org/install | bash
```
02
Finish setup in the browser.

A web wizard walks you through admin account and organization. The check executor installs itself right after, and Vesana scans your network once — the first devices appear on their own.
```
# in your browser
https://your-server/setup
```

03

Add more hosts.

Download the agent or collector from the UI, paste token + URL. Done.

# on the target host
wget -qO- https://your.vesana/agent/install.sh | \
    bash -s -- TOKEN https://your.vesana