Uptime Kotlin is another useful entry in the current wave of self-hosted monitoring tools.

Uptime Kotlin is a self-hosted uptime monitoring platform built with Kotlin, Quarkus, React, and PostgreSQL. It monitors HTTP/HTTPS, TCP, DNS, ping, PostgreSQL, Microsoft SQL Server, MySQL/MariaDB, Redis, SMTP, Kafka, and RabbitMQ, while also providing public status pages and multi-channel notifications.

That makes it more infrastructure-protocol-heavy than Statup, more app-like than Gatus, and closer to Uptime Kuma in the “self-hosted monitoring dashboard” category.

Uptime Kotlin = Quarkus API + React UI + PostgreSQL + scheduler/worker checks

What is Uptime Kotlin?

The repository I checked was:

Repository: https://github.com/TheoMeunier/uptime-kotlin
Checked commit: 787b0f9e6787baf1344dc2c0173c3ce16d03e2ac
Commit date: 2026-10-09
Latest checked tag: v1.3.0
License: MIT
Backend: Kotlin, Quarkus, Hibernate/Panache, Flyway
Frontend: React, Vite, TypeScript, Tailwind
Database: PostgreSQL
Container image tested: ghcr.io/theomeunier/uptime-kotlin:1.3.0

The standard image is all-in-one: web interface, API, and monitoring checks. For larger installations, the same project also publishes a worker image that can run checks separately while the API runs with scheduling disabled.

Why It Is Interesting

Most lightweight uptime tools start with HTTP checks and add a few extras.

Uptime Kotlin starts with a broader set of infrastructure protocols:

Category Supported Checks
Web/network HTTP/HTTPS, TCP, ping, DNS
Databases PostgreSQL, Microsoft SQL Server, MySQL/MariaDB, Redis
Messaging Kafka producer, RabbitMQ
Mail SMTP

That makes it useful when you want one dashboard that can check more than “does this web page return 200?”

Features

The README highlights:

  • real-time dashboard with historical data;
  • public status pages;
  • multi-channel notifications;
  • encrypted secrets;
  • JWT authentication;
  • single Docker image for amd64 and ARM64;
  • optional worker-based cluster mode;
  • periodic resend while a monitor stays down, configured per monitor and disabled by default.

Notification channels in the source include:

  • Email;
  • Slack;
  • Discord;
  • Microsoft Teams;
  • Telegram;
  • ntfy;
  • Gotify;
  • generic webhook.

Self-Hosting Uptime Kotlin with Docker

I added a Home-Lab compose folder here:

Home-Lab Uptime Kotlin compose

The compose pins the 1.3.0 image and publishes the app on port 3812:

services:
  uptime-kotlin:
    image: ${UPTIME_KOTLIN_IMAGE:-ghcr.io/theomeunier/uptime-kotlin:1.3.0}
    container_name: uptime-kotlin
    restart: unless-stopped
    mem_limit: ${UPTIME_KOTLIN_MEM_LIMIT:-512m}
    ports:
      - "${UPTIME_KOTLIN_BIND:-0.0.0.0}:${UPTIME_KOTLIN_PORT:-3812}:8080"
    environment:
      TZ: ${TZ:-Europe/Warsaw}
      QUARKUS_DATASOURCE_USERNAME: ${POSTGRES_USER:-uptime-kotlin}
      QUARKUS_DATASOURCE_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
      QUARKUS_DATASOURCE_JDBC_URL: jdbc:postgresql://postgres:5432/${POSTGRES_DB:-uptime-kotlin}
      ENCRYPTION_MASTER_KEY: ${ENCRYPTION_MASTER_KEY:?Set ENCRYPTION_MASTER_KEY in .env}
      ENCRYPTION_PREVIOUS_MASTER_KEYS: ${ENCRYPTION_PREVIOUS_MASTER_KEYS:-}
      MP_JWT_VERIFY_ISSUER: ${MP_JWT_VERIFY_ISSUER:-http://192.168.1.2:3812}
      SCHEDULER_STRATEGY: ${SCHEDULER_STRATEGY:-database}
      SCHEDULER_WORKER_CONCURRENCY: ${SCHEDULER_WORKER_CONCURRENCY:-4}
      MAINTENANCE_HORIZON_DAYS: ${MAINTENANCE_HORIZON_DAYS:-90}
      MAINTENANCE_MAX_DURATION_HOURS: ${MAINTENANCE_MAX_DURATION_HOURS:-24}
      NOTIFICATIONS_DISPLAY_TIMEZONE: ${NOTIFICATIONS_DISPLAY_TIMEZONE:-Europe/Warsaw}
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - uptime-kotlin

  postgres:
    image: ${POSTGRES_IMAGE:-postgres:17.4-alpine}
    container_name: uptime-kotlin-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB:-uptime-kotlin}
      POSTGRES_USER: ${POSTGRES_USER:-uptime-kotlin}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
      PGDATA: /var/lib/postgresql/data/pgdata
    volumes:
      - uptime-kotlin-postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-uptime-kotlin} -d ${POSTGRES_DB:-uptime-kotlin}"]
      interval: 10s
      timeout: 5s
      retries: 10
    networks:
      - uptime-kotlin

volumes:
  uptime-kotlin-postgres:

networks:
  uptime-kotlin:
    driver: bridge
    ipam:
      config:
        - subnet: ${UPTIME_KOTLIN_SUBNET:-10.89.12.0/24}

Start it:

cd uptime-kotlin
cp .env.sample .env
openssl rand -base64 32
nano .env
docker compose up -d

Open:

http://192.168.1.2:3812

Health check:

curl http://127.0.0.1:3812/q/health

Field Note: Local Trial

For the local trial I used:

ghcr.io/theomeunier/uptime-kotlin:1.3.0
postgres:17.4-alpine

The compose uses a 512 MB memory limit for the app container. The README specifically recommends setting a memory limit because the native Quarkus heap is sized from the memory the container sees.

The local URL is:

http://192.168.1.2:3812

The health endpoint returned UP with database, scheduler, worker loop, and reactive messaging checks:

curl http://127.0.0.1:3812/q/health

The setup status endpoint returned:

{"status":"false"}

That means no first user exists yet. Create the initial account through the UI.

One infrastructure note from this host: Docker refused to create another default Compose network because too many existing networks had already consumed the default address pools. The Home-Lab compose now assigns an explicit subnet:

UPTIME_KOTLIN_SUBNET=10.89.12.0/24

That is not an Uptime Kotlin problem; it is a practical homelab side effect after many local app trials.

Uptime Kotlin has an onboarding/setup API for the first user. There is no default admin password in the compose; create the first account through the UI.

Where It Fits Beside Uptime Kuma, Statup, Maintenant, and Beszel

Tool Best Fit
Uptime Kotlin Broad protocol monitoring, status pages, notification routing, PostgreSQL-backed history, optional worker scaling
Uptime Kuma Mature, easy uptime checks and push monitors with many notification integrations
Statup Human-readable incident, maintenance, announcement, and status communication
Maintenant Docker/Kubernetes runtime monitoring, logs, updates, certs, security insights, status pages
Beszel Lightweight host/container resource metrics

Uptime Kotlin is closer to Uptime Kuma than Statup. The main difference is its Kotlin/Quarkus/PostgreSQL architecture and the breadth of built-in protocol checks.

FAQ

Conclusion

Uptime Kotlin is a serious self-hosted monitoring app with a modern JVM-native backend, React dashboard, PostgreSQL storage, broad protocol support, notifications, and status pages.

It is heavier than Uptime Kuma or Statup, but that is partly the point: it is designed more like an application platform for monitoring checks, with encrypted secrets and optional workers.

For a homelab, I would test it beside Uptime Kuma rather than replace anything immediately. The interesting part is whether the broader protocol list and worker model solve checks that your current uptime dashboard does not handle cleanly.