Altimey

Preview Live
React TypeScript Node.js PostgreSQL RabbitMQ Docker TailwindCSS Razorpay
Altimey

Table of Contents

This is a list of all the sections in this post. Click on any of them to jump to that section.

Description

Altimey is a full-featured SaaS uptime monitoring platform designed to help teams track the availability and performance of their services in real time. The platform supports multiple monitoring types including HTTP, DNS, port, ping, and cron-based checks, providing a comprehensive infrastructure monitoring solution.

Built with a scalable scheduler–worker architecture, Altimey processes monitoring jobs asynchronously using message queues to ensure reliable and high-throughput checks across large numbers of services.

The platform includes real-time dashboards, alerting systems, public status pages, and subscription-based billing, making it suitable for both individual developers and team-based organizations.

Tech Stack

  • Frontend: React, TypeScript, Tailwind CSS
  • Backend: Node.js, TypeScript
  • Database: PostgreSQL
  • Queue System: RabbitMQ
  • Payments: Razorpay (recurring subscriptions)
  • Infrastructure: Docker
  • Notifications: 15+ integrated third-party services (email, messaging, etc.)

Key Features

  • Multi-Type Monitoring — Supports HTTP, DNS, port, ping, and cron job monitoring.
  • Real-Time Alerts — Instant notifications through multiple third-party integrations when incidents occur.
  • Public Status Pages — Automatically generated status pages for transparent service availability.
  • Team Workspaces — Multi-user collaboration with role-based access control.
  • Subscription Billing — Paid plans powered by Razorpay recurring subscriptions.
  • Custom Dashboards — Visual insights into uptime history, response times, and incidents.
  • High-Throughput Monitoring Engine — Asynchronous processing using RabbitMQ workers.

Architecture & System Design

Altimey uses a distributed scheduler–worker architecture to efficiently handle monitoring tasks at scale:

  1. Scheduler Service — Periodically schedules monitoring checks.
  2. RabbitMQ Queue — Distributes monitoring jobs asynchronously.
  3. Worker Services — Execute checks and collect response metrics.
  4. PostgreSQL Database — Stores monitor configurations, results, and incidents.
  5. API Layer — Serves dashboards, alert configurations, and team management features.

This design ensures fault tolerance, scalability, and efficient job distribution across workers.

Challenges & Solutions

1. Handling High-Frequency Monitoring Jobs

Challenge: Running thousands of monitoring checks without blocking the API server.

Solution: Implemented a queue-based architecture with RabbitMQ, separating scheduling and execution via dedicated worker processes.

2. Reliable Alert Delivery

Challenge: Ensuring alerts reach users quickly and reliably across multiple channels.

Solution: Integrated 15+ third-party notification services with retry mechanisms to guarantee delivery during incidents.

3. Multi-Tenant SaaS Architecture

Challenge: Supporting teams with multiple members and shared monitors.

Solution: Implemented workspace-based multi-tenancy with role-based permissions, allowing teams to manage monitors collaboratively.

4. Subscription Billing & Plan Management

Challenge: Managing recurring billing and feature limits for paid users.

Solution: Integrated Razorpay recurring subscriptions to automate billing cycles and enforce plan-based limits.

What I Learned

  • Designing distributed job processing systems using RabbitMQ.
  • Building scalable monitoring infrastructure with worker-based architectures.
  • Implementing multi-tenant SaaS systems with role-based access control.
  • Handling recurring subscription billing and plan management.
  • Deploying production services using Docker-based infrastructure.