Forem: Alexander Neitzel

Facebook Outage 2021: What You Missed (And How External Monitoring Keeps You Safe)

Alexander Neitzel — Wed, 09 Jul 2025 11:06:25 +0000

On October 4, 2021, Facebook, Instagram, WhatsApp and Messenger all went dark for over 6 hours, affecting billions worldwide.

The outage wasn’t just a blip—it was a wake-up call:

Even the biggest platforms go down. Are you ready if yours does?

⚠️ What Actually Happened

A faulty update to Facebook’s backbone network routers caused DNS disruptions
This sealed off Facebook’s internal systems — including monitoring, recovery tools, internal dashboards and even office access
The issue persisted for ~6 hours, with global knock-on effects across digital businesses and workflows

🧠 Why Internal Tools Fell Short

Internal monitoring died with the network — no visibility when your infra “transforms into a black box”
Even internal response teams couldn’t login or use tools
No fallback — everything was dead until the network was fixed

✅ Why External Monitoring + Status Pages Matter

Benefit	Why It Helps
✅ External alerts	Get notified even if your entire network is down
🌍 Global checks	Detect DNS or routing failures anywhere
🌐 Public status pages	Inform customers transparently
📊 SLA and uptime tracking	Build trust with data
📄 PDF reports & compliance	Use in postmortem and legal audits

🛠️ How Garmingo Status Keeps You Covered

With Garmingo Status:

🚨 Externally located monitors across geos
🔔 Alerts to Slack, Email, Telegram, Discord, Webhooks
🌐 Optional public & private status pages
📉 Historical uptime + SLA dashboards
🧾 Exportable PDF reports for teams
🆓 Lifetime AppSumo deal (<$50) or free forever plan

👉 Secure your lifetime monitoring today

💡 Final Takeaway

Facebook taught us: failure can be existential—even at scale.

Relying only on internal tools? That’s a risk you can’t (and shouldn’t) afford.

External monitoring and status pages are essential resilience infrastructure.

👉 Try Garmingo Status free or get lifetime access now:

Lifetime AppSumo Deal

What You Can Learn from the AWS US‑East‑1 Outage

Alexander Neitzel — Wed, 09 Jul 2025 10:56:27 +0000

On December 7, 2021, AWS suffered a major outage in its US‑East‑1 region, impacting tens of thousands of services—from streaming apps to SaaS dashboards to smart home devices. The outage lasted approximately 5 hours and demonstrated a critical truth:

When your cloud provider fails, so does your application—unless you detect it externally.

⚠️ What Happened

AWS reported a severe disruption to several Amazon services and partner apps, including Amazon website, Elastic Compute Cloud (EC2), Elastic Load Balancer (ELB), Alexa, etc.
The root cause was an I/O degradation in Kinesis, which triggered a series of reliance failures across internal services.
The issue took ~5 hours to fully resolve, with recovery beginning in the US‑East‑1 area and spilling over to other regions.

🚨 Why This Matters to You

Most monitoring is inside your AWS account—so if AWS itself fails, your monitoring dies with it.
Deploy pipelines, dashboards, and even incident responders didn’t know until users started complaining.
You need external alerting to truly know when your app is impacted.

🔍 How Garmingo Status Protects You

Using Garmingo Status:

🌍 Health checks from multiple global locations
🚨 Instant alerts through Slack, Email, Telegram, Discord, Webhook
🧾 Public or private status pages to communicate during outages
📈 SLA tracking & PDF reports for compliance or transparency
🆓 One-time payment on AppSumo or free forever plan

👉 Grab the Lifetime Deal on AppSumo

👉 Or try Garmingo for free

✅ Lessons Learned

Insight	Action
Don’t rely only on provider-side monitoring	Add external uptime checks
Public status pages build trust	Share live updates with users
Track SLA over time	Hold yourself (not AWS) accountable
Use multi-location monitoring	Catch regional cloud issues fast

🧘 TL;DR

Cloud providers fail. That’s not a surprise—it’s a fact.

But you don’t need to fail with them.

External, global monitoring with proactive alerting is your buffer.

👉 Lifetime Lifetime Deal – Garmingo Status on AppSumo

👉 Free forever demo available

CrowdStrike Outage 2024: Lessons Learned and Why You Need External Monitoring

Alexander Neitzel — Wed, 09 Jul 2025 10:51:04 +0000

On July 19, 2024, a faulty configuration update from CrowdStrike triggered a blue screen of death on approximately 8.5 million Windows devices, causing the largest IT outage in history. From airline systems to banks, hospitals to broadcasters — the fallout was global  Source.

The incident lasted for days in some cases, grounding flights, crippling emergency services, and taking down critical systems.

🔍 What Happened

A flawed Falcon sensor update (Channel File 291) caused BSOD crashes on Windows hosts
Initial rollout began at 04:09 UTC
An estimated 8.5 million devices crashed, with ripple effects through Azure and other services  Source Source
Recovery was slow — manual fixes and patch rollouts took days or weeks in many environments  Source

🌍 Global Disruption

Delta Air Lines canceled over 7,000 flights and lost an estimated \$500 million — more days of disruption followed  Source
UK financial regulators reported firms must improve resilience after the event  Source
CrowdStrike’s market cap dropped by over a third, costing investors tens of billions, before partially recovering later in the year  Source

🧠 Why Internal Monitoring Failed

The crash happened on the endpoint side — internal servers and services were unaffected
Self-hosted tools can't watch themselves: If the entire machine crashes, there's no one to alert you
No multi-region or external visibility, so admins had no clue until users reported failures

✅ Why External Monitoring Matters

Benefit	Why It Helps
🌍 Multi-location checks	Detect regional or endpoint-level failures
🔔 External alerts	You’ll know when the machine or service is offline
📈 SLA & history	Show reliability over time and pinpoint fault
🌐 Public / private status pages	Communicate transparently with users/stakeholders
📄 Reports & compliance	Essential for audits, insurance, and recovery guidelines

🛠️ Enter Garmingo Status

With Garmingo Status:

🌍 Monitoring from multiple global locations
🔔 Alerts via Slack, Email, Telegram, Discord, Webhooks
📊 Uptime dashboards and SLA tracking
🧾 PDF and compliance-ready reports
📣 Public or internal status pages to keep everyone informed
🆓 A one-time‑purchase Lifetime Deal (~\$50) or Free Demo

👉 Get Garmingo Status Lifetime Deal on AppSumo

💡 Final Takeaway

The CrowdStrike outage was a wake-up call — even the backbone of enterprise security can fail.

Internal tools alone can’t give you that external check when disaster strikes.

✅ External, multi-location, SLA-tracked monitoring with instant alerts and status pages is no longer optional — it’s essential.

👉 Try Garmingo Status for free or secure lifetime uptime with the AppSumo Lifetime Deal.

🧘 TL;DR

A single faulty update broke millions of systems and cost billions.

External monitoring is your safety net — don’t wait until it’s too late.

Grab Garmingo Status today — lifetime access or free trial.

Lessons from the June 2025 Google Cloud Outage (And How Monitoring Could Have Saved You)

Alexander Neitzel — Wed, 09 Jul 2025 10:42:30 +0000

🚨 Lessons from the June 2025 Google Cloud Outage (And How Monitoring Could Have Saved You)

On June 12, 2025, a faulty quota configuration in Google Cloud’s API management system triggered widespread 503 errors across Google Cloud, Workspace, and many third-party apps like Spotify, Discord, and Cloudflare *0 *1.

Duration: ~3 hours (10:49 AM–1:49 PM Pacific)

Global impact: DNS failures, deployment blocks, broken identity services — chaos.

🧠 What Went Wrong

Google published that an invalid automated quota update was pushed globally, overloading the policy system since quota checks are regional.

They ultimately bypassed the faulty policy, but recovery took 2‑3 hours, with regions like us‑central1 taking longest *2.

🚫 Who Got Hit

Nearly 70+ Google services disrupted (e.g. Gmail, Drive, Cloud Console) *3
External platforms like Spotify, Discord, OpenAI went dark *4
Dev teams couldn’t deploy, support tools failed, authentication systems broke — widespread infra paralysis.

🕵️ Why Monitoring Doesn’t Guarantee Availability, But Helps Fast Recovery

Internal checks on a single region don’t reveal external user impact
An external monitoring tool could have alerted you in minutes — not hours
You wouldn’t need to build your own status page around broken tools
Multi-location checks ensure visibility even if your provider or region is down

🛠️ How Garmingo Status Protects You

With Garmingo Status:

🌍 Global checks from multiple regions
📉 Track uptime & SLA performance
📣 Get instant alerts via Slack, Email, Telegram, Discord…
👁️‍🗨️ Publish public/private status pages
📄 Generate incident reports & PDF uptime history
🆓 Lifetime access under $50 (AppSumo Deal) or free forever option

👉 Grab your Garmingo Status Lifetime Deal

💡 Key Takeaways

Lesson	What You Can Do
Real-time external monitoring is a must	Set up global uptime checks
Status pages speed up user trust recovery	Publish incident updates proactively
SLA tracking ensures accountability	Report uptime to stakeholders
Multi-location ensures resilience	Detect regional P0 outages early

In a world where cloud providers fail, don’t be the last to know.

👉 Ready for uptime you control?

Try Garmingo Status free or lock in the AppSumo Lifetime Deal below.

TL;DR

A ~3‑hour Google Cloud outage wreaked havoc on global services. With external monitoring, five-minute alerts, SLA tracking, and status page capabilities, Garmingo Status could help you be the first to know — and keep your users informed.

Lifetime access = 💸 under $50 one-time.

👉 Lifetime Deal on AppSumo

How to Self-Host AnythingLLM — Your Own AI Knowledge Base with Monitoring

Alexander Neitzel — Tue, 08 Jul 2025 15:08:57 +0000

🤖 How to Self-Host AnythingLLM — Your Own AI Knowledge Base with Monitoring

Want ChatGPT, but trained on your own docs?

Want to host it yourself, with no limits or spying?

AnythingLLM gives you that:

→ Self-hosted RAG (Retrieval-Augmented Generation) with OpenAI or Local LLMs

→ Drop in PDFs, Docs, Markdown, Notion pages, websites

→ Slick UI, document management, even team features

In this guide, you’ll learn how to:

Run AnythingLLM on your own Linux server
Use Docker to keep it isolated
Load up your docs
Monitor your LLM uptime like a pro

🧰 What You’ll Need

A Linux server (Ubuntu/Debian) 👉 We recommend Hetzner Cloud — great pricing & performance
Docker + Docker Compose
OpenAI API key or Local LLM (e.g. Ollama)
Docs you want to load
5–10 minutes

🛠️ Step 1: Clone AnythingLLM

git clone https://github.com/Mintplex-Labs/anything-llm.git  
cd anything-llm

⚙️ Step 2: Configure the Environment

Copy the example file:

cp .env.example .env

Open .env and update:

OPENAI_API_KEY=your-openai-key
Or set Ollama / Local LLM variables
Choose vector DB (Supabase is default)

📦 Step 3: Run with Docker

Build and start:

docker compose up -d --build

Cool! Now visit:

http://your-server-ip:3001

Set up your admin account and log in.

🧠 Step 4: Load Your Documents

You can now:

Upload PDFs
Paste text
Connect Notion or URLs
Create multiple workspaces

Once ingested, you can chat with the content via the UI.

🧪 Step 5: (Optional) Run Ollama Locally

If you don’t want OpenAI, install Ollama on the same or another server:

curl -fsSL https://ollama.com/install.sh | sh  
ollama run llama3

Then point AnythingLLM to your local endpoint in .env.

📡 Step 6: Monitor AnythingLLM with Garmingo Status

Your AI knowledge base is now running — but is it reliable?

If it goes down, your productivity (or users) go with it.

Make sure it stays up with Garmingo Status:

✅ Monitor your IP or domain

✅ Set alerts (Slack, Email, Telegram, Discord, etc.)

✅ Multi-location uptime checks

✅ Public or private status pages

✅ SLA tracking + monthly reports

✅ One-time payment → Lifetime Deal!

🎁 Grab it on AppSumo here — under $50, no subscription.

🧘 TL;DR

🧠 AnythingLLM gives you private ChatGPT with your docs
🐳 Self-host it with Docker
📊 Monitor it with Garmingo Status
💸 No monthly fees — forever

👉 Get Lifetime Access to Garmingo on AppSumo

👉 Or test it free

👉 Run it on Hetzner

How to Self-Host Coolify (Open Source Heroku) — With Monitoring & Free Lifetime Alerts

Alexander Neitzel — Tue, 08 Jul 2025 15:05:19 +0000

🚀 How to Self-Host Coolify (Open Source Heroku) — With Monitoring & Free Lifetime Alerts

Coolify is a brilliant open-source platform that lets you self-host your own Heroku-style PaaS.

Deploy apps, databases, workers, and more — all from one dashboard.

In this guide, you’ll learn how to:

Deploy Coolify using Docker
Host it on a budget-friendly server
Monitor it from the outside with Garmingo Status
All without paying monthly

Let’s build your own mini-PaaS 👇

🧰 What You’ll Need

A Linux server (Ubuntu/Debian) 👉 We recommend Hetzner Cloud — fast, reliable, cheap (€3/month)
Docker + Docker Compose
Domain (optional but recommended)
5–10 minutes

🛠️ Step 1: Prepare Your Server

Update & install Docker:

sudo apt update && sudo apt install docker.io docker-compose -y

Add your user to the docker group:

sudo usermod -aG docker $USER  
newgrp docker

📦 Step 2: Deploy Coolify

Run:

docker run -d \  
  --name coolify \  
  -p 3000:3000 \  
  -v /var/run/docker.sock:/var/run/docker.sock \  
  -v coolify-data:/app/data \  
  ghcr.io/coollabsio/coolify

Once it's running, go to:

http://your-server-ip:3000

Create your account and log in to the dashboard.

🌐 Step 3: Add Domain & HTTPS (Recommended)

Coolify supports automatic Let's Encrypt provisioning if you point a domain (e.g. coolify.yourdomain.com) to the server IP.

Set this in the dashboard or behind a reverse proxy.

📈 Step 4: Start Deploying Stuff

Coolify can handle:

Static apps
Dockerfiles & Git repos
Databases like PostgreSQL & MySQL
Background workers & CRON jobs

You can even build CI/CD pipelines with webhooks or Git integration.

🚨 Step 5: Monitor Coolify with Garmingo Status

Coolify is your app platform. If it goes down, everything breaks.

You need visibility outside your own stack.

That’s where Garmingo Status comes in:

✅ External uptime monitoring

✅ Multi-location checks

✅ Slack, Email, Discord & Webhook alerts

✅ Private or public status pages

✅ PDF reports & SLA logs

✅ Forever free tier or one-time payment → Lifetime deal!

👉 Grab the Lifetime Deal here (under $50!)

You host your own PaaS. Now make sure it's always up.

🧘 TL;DR

🧰 Install Coolify with Docker
🌐 Add a domain + TLS
🚀 Deploy your apps
📡 Monitor it with Garmingo Status
💸 Never pay monthly again

👉 Try the Lifetime Plan on AppSumo

👉 Or start free here

How to Self-Host SonarQube for Code Quality Analysis (with Monitoring)

Alexander Neitzel — Tue, 08 Jul 2025 14:59:25 +0000

🧪 How to Self-Host SonarQube for Code Quality Analysis (with Monitoring)

SonarQube is one of the best tools to catch bugs, security issues, and code smells — especially for larger projects and teams.

Good news: it’s open-source and easy to self-host.

In this guide, you’ll learn how to:

Set up SonarQube on your own server
Run it with Docker
Monitor it externally to keep your CI/CD reliable
Do all of this for a one-time lifetime price, no monthly bill

Let’s go 👇

🧰 What You’ll Need

A Linux server (Ubuntu/Debian) 👉 If you need one, we recommend Hetzner Cloud — fast, reliable and cheap VPS starting at €3.
Docker + Docker Compose
5–10 minutes

⚙️ Step 1: Create a Project Folder

mkdir sonarqube && cd sonarqube

📦 Step 2: Create a `docker-compose.yml`

Paste this config:

version: "3"

services:
  sonarqube:
    image: sonarqube:lts
    ports:
      - "9000:9000"
    environment:
      - SONAR_JDBC_URL=jdbc:postgresql://db:5432/sonarqube
      - SONAR_JDBC_USERNAME=sonar
      - SONAR_JDBC_PASSWORD=sonar
    depends_on:
      - db

  db:
    image: postgres:13
    environment:
      - POSTGRES_USER=sonar
      - POSTGRES_PASSWORD=sonar
      - POSTGRES_DB=sonarqube
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

🚀 Step 3: Start SonarQube

Run:

docker compose up -d

After a minute, open:

http://your-server-ip:9000

Default credentials:

User: admin
Pass: admin

🔐 Step 4: Secure Your Instance

Change the default password
Add HTTPS using a reverse proxy (e.g. NGINX + Let’s Encrypt)
Use a firewall (e.g. UFW) to restrict access if needed

🔍 Step 5: Start Analyzing Code

You can now connect your GitHub/GitLab/Bitbucket repos or run CLI scans.

Check code coverage, vulnerabilities, bugs, complexity and more.

✅ Step 6: Monitor SonarQube with Garmingo Status

SonarQube is often tied into your CI/CD pipeline.

If it goes down, builds fail and productivity suffers.

Here’s how to prevent that:

Use Garmingo Status to:
- Monitor http(s)://yourdomain.com:9000
- Track uptime & receive real-time alerts (Email, Slack, Telegram, etc.)
- Maintain SLA logs and export reports
- Set up internal or public status pages
It even has Ping, Port, DNS, Keyword, and SSL checks

🎉 Right now, you can get Lifetime Access for under $50 on AppSumo:

👉 Grab the Garmingo Status Lifetime Deal

🧘 TL;DR

🐳 Spin up SonarQube in Docker
🔒 Secure your instance
📈 Monitor it with Garmingo Status
✅ Pay once — not monthly

Peace of mind = priceless. But in this case, it's actually just $49.

👉 Get Lifetime Monitoring on AppSumo

How to Self-Host PostgreSQL (with Monitoring)

Alexander Neitzel — Sun, 11 May 2025 15:55:59 +0000

PostgreSQL is the backbone of tons of modern apps — powerful, reliable, and open-source.

And yes, self-hosting it is totally doable.

In this guide, we’ll go through:

Installing PostgreSQL on a Linux server
Basic security & setup
Optional access via pgAdmin
Monitoring your database with Garmingo Status for full visibility

🧰 What You’ll Need

A Linux server (Ubuntu, Debian, etc.)
sudo/root access
~10 minutes

⚡ Step 1: Install PostgreSQL

Update your server:

sudo apt update && sudo apt upgrade -y

Install PostgreSQL:

sudo apt install postgresql postgresql-contrib -y

Check status:

sudo systemctl status postgresql

🛡️ Step 2: Set a Password for the `postgres` User

Switch to the postgres user:

sudo -i -u postgres

Then access the PostgreSQL shell:

psql

Set a password:

\password postgres

Exit with:

\q  
exit

🧱 Step 3: Create a Database & User

sudo -i -u postgres  
createdb myappdb  
createuser myappuser  
psql

In the shell:

ALTER USER myappuser WITH ENCRYPTED PASSWORD 'strongpass';  
GRANT ALL PRIVILEGES ON DATABASE myappdb TO myappuser;  
\q  
exit

🔐 Step 4: Enable Remote Access (Optional)

Edit config:

sudo nano /etc/postgresql/*/main/postgresql.conf

Change:

listen_addresses = '*'

Then:

sudo nano /etc/postgresql/*/main/pg_hba.conf

Add:

host    all             all             0.0.0.0/0            md5

Restart:

sudo systemctl restart postgresql

🌐 Step 5: (Optional) Use pgAdmin for GUI Access

Install pgAdmin via Docker, Snap, or locally.

Connect using:

Host: your-server-ip
Port: 5432
User: myappuser
Password: the one you set

✅ Step 6: Monitor PostgreSQL with Garmingo Status

Postgres is mission-critical. If it goes down, everything breaks.

Here’s how to make sure that never happens:

Go to Garmingo Status
Add a Port monitor for 5432 on your server’s IP
Get alerts via Email, Slack, Telegram, Discord, or Webhooks
View historical uptime
Log incidents
Generate monthly SLA reports

🆓 All available on the forever free plan, no credit card required.

👉 Set up your DB monitoring now

🧘 TL;DR

✅ Install PostgreSQL
🔐 Secure + configure remote access
🛠️ Create user + DB
📊 Monitor uptime and availability with Garmingo Status

Because databases don’t break often —

…but when they do, it hurts.

👉 Get real monitoring now

How to Self-Host Uptime Kuma (And When You Should Use Something Better)

Alexander Neitzel — Sun, 11 May 2025 15:48:09 +0000

Uptime Kuma is a great open-source tool — simple, fast, and easy to run on your own server.

If you’re just getting started with monitoring or want something lightweight for internal use, it’s an awesome choice.

But if you’re running production infrastructure, working with SLAs, or need real visibility and compliance, you’ll eventually hit its limits.

Let’s start by showing you how to set it up — and then we’ll explain where it stops short 👇

🧰 What You’ll Need

Linux server (Ubuntu, Debian, etc.)
Docker + Docker Compose
Optional: domain + SSL
5 minutes

🚀 Step 1: Project Setup

mkdir uptime-kuma && cd uptime-kuma

⚙️ Step 2: Docker Compose Config

version: '3.3'

services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    restart: always
    ports:
      - "3001:3001"
    volumes:
      - ./data:/app/data

🧱 Step 3: Deploy It

docker compose up -d

Now access Kuma at:

http://your-server-ip:3001

Create an admin user and you’re ready to go.

📊 Step 4: Add Monitors

Kuma supports:

HTTP(s), Ping, Port, DNS, Keyword
Alerts via Email, Telegram, Discord, Slack & more

🌐 Step 5: Optional – Add a Custom Domain

Point status.yourdomain.com to your server.

Use a reverse proxy with Let’s Encrypt for HTTPS.

🤔 But Here’s the Catch

Uptime Kuma is self-hosted monitoring.

It only works as long as your server works.

Which means:

❌ No alerts if the entire server is offline
❌ No geo-distributed checks
❌ No SLA reports or compliance features
❌ No multi-tenant team management
❌ No support, no guarantees, no roadmap
❌ No easy public status pages or incident comms

✅ The Better Alternative: Garmingo Status

If you need real monitoring that:

🌍 Checks from multiple global locations
📈 Tracks uptime history & SLA targets
🧾 Generates automated PDF reports
🔐 Supports compliance & access control
💬 Offers status pages (public or private)
📣 Sends alerts via Slack, Email, Telegram, Webhooks, etc.
🙌 Has a responsive support team & active roadmap
💡 Stays online even when your infra crashes

Then Garmingo Status is the better choice — full stop.

And yes: there’s a forever free plan, no credit card needed.

👉 Try it free here

🧘 TL;DR

🟢 Uptime Kuma is a great open-source tool for small setups
🔴 But self-hosted monitoring can’t monitor itself
🔥 Garmingo Status gives you external, reliable, production-ready monitoring

If your uptime actually matters — Garmingo is what you want watching it.

👉 Start your free monitoring stack today

How to Self-Host Kimai (Time Tracking) on Linux (with Monitoring)

Alexander Neitzel — Sun, 11 May 2025 15:39:43 +0000

Kimai is a slick, open-source time tracking tool — great for freelancers, teams, and agencies who want full control and privacy.

In this guide, I’ll show you how to self-host Kimai using Docker on any Linux server (Ubuntu, Debian…), get it up and running in minutes, and make sure it stays online 24/7 with monitoring from Garmingo.

Let’s go 👇

🧰 What You’ll Need

A Linux server with Docker + Docker Compose
Basic terminal access (SSH)
Optional: domain + HTTPS
10 minutes

🚀 Step 1: Create a Project Directory

mkdir kimai && cd kimai

⚙️ Step 2: Create a `docker-compose.yml`

Paste this into docker-compose.yml:

version: '3.7'

services:
  kimai:
    image: kimai/kimai2:apache
    restart: unless-stopped
    ports:
      - "8001:8001"
    environment:
      - ADMINMAIL=admin@yourdomain.com
      - DATABASE_URL=mysql://kimai:kimai@db/kimai
    depends_on:
      - db

  db:
    image: mysql:5.7
    restart: unless-stopped
    environment:
      - MYSQL_DATABASE=kimai
      - MYSQL_USER=kimai
      - MYSQL_PASSWORD=kimai
      - MYSQL_ROOT_PASSWORD=rootpass
    volumes:
      - mysql_data:/var/lib/mysql

volumes:
  mysql_data:

🧱 Step 3: Launch Kimai

Run the stack:

docker compose up -d

Wait a minute, then open:

http://your-server-ip:8001

Login with:

Username: admin
Password: changeme

Change your password immediately.

🌐 Step 4: Optional – Add Domain + SSL

Point time.yourdomain.com to your server.

Use a reverse proxy like Caddy, Nginx Proxy Manager, or Traefik to:

Forward HTTPS requests to port 8001
Secure the connection with Let’s Encrypt

🧪 Step 5: Start Tracking Time

Log in → create customers, projects, and time entries.

You can also invite your team and enable timesheets, exports, and invoice generation.

✅ Step 6: Monitor Your Kimai Instance with Garmingo Status

Kimai handles critical workflows — especially for clients, timesheets, and billing.

If it goes offline and you don’t know… you’ve got problems.

Set up Garmingo Status to:

Monitor https://time.yourdomain.com or your IP
Alert you via Slack, Email, Telegram, Discord, or Webhook
Show uptime history & log incidents
Share a public or private status page
Get monthly uptime reports

🆓 All available on the forever free plan — no credit card needed.

👉 Set up your monitoring now

🧘 TL;DR

✅ Deploy Kimai with Docker
🔐 Secure with domain + HTTPS
🕵️ Track your time
📈 Monitor with Garmingo Status

Time tracking shouldn’t stop when your server crashes.

👉 Monitor your Kimai instance today

How to Self-Host Infisical (with Monitoring)

Alexander Neitzel — Sun, 11 May 2025 15:36:20 +0000

Infisical is a modern, open-source secret manager for developers — think self-hosted Doppler or Vault, but simpler and actually enjoyable to use.

In this guide, I’ll show you how to deploy Infisical using Docker on any Linux server (Ubuntu, Debian, etc.), configure your environment, and keep your setup online and secure with uptime monitoring.

Let’s go 👇

🧰 What You’ll Need

A Linux server (Debian/Ubuntu preferred)
Docker & Docker Compose installed
A domain + SSL (optional but recommended)
10 minutes

🚀 Step 1: Clone the Infisical Repo

git clone https://github.com/infisical/infisical.git  
cd infisical/self-host

⚙️ Step 2: Configure the .env File

Copy the example file:

cp .env.template .env

Edit values in .env to match your setup. At minimum, update:

NODE_ENV=production  
ENCRYPTION_KEY=generate-strong-key  
DATABASE_URL=postgresql://infisical:password@db:5432/infisical

You can generate a strong encryption key with:

openssl rand -hex 32

🛢️ Step 3: Set Up Docker Compose

Infisical includes a ready-to-use docker-compose.yml. Just run:

docker compose up -d

This launches:

The Infisical server
A PostgreSQL database
A Redis cache

After a few seconds, your instance should be available at:

http://your-server-ip:8080 or your custom domain.

🌐 Step 4: Add HTTPS and a Domain (Optional)

Use a reverse proxy (Caddy, Nginx, Traefik) to expose Infisical securely:

Point secrets.yourdomain.com to your VPS
Use Let’s Encrypt for SSL
Proxy port 8080 to HTTPS

🧪 Step 5: Login & Create Your First Project

Head to the web UI → sign up → create your first workspace.

Infisical lets you securely store .env variables, share secrets between team members, and integrate into CI/CD pipelines.

✅ Step 6: Add Monitoring with Garmingo Status

Your secrets system is now live. But what happens when it goes down?

💡 Secret managers are core infra. Downtime = deploys break, apps crash, teams blocked.

Here’s how to make sure that never happens:

Create a free account at Garmingo Status
Add a monitor for your Infisical URL (https://secrets.yourdomain.com)
Set alerting to Slack, Email, Telegram, Discord, or Webhooks
(Optional) Create a private status page for internal visibility

You’ll get:

Realtime alerts
Incident logs
SLA tracking
Monthly uptime reports
Peace of mind

👉 Get started here

🧘 TL;DR

✅ Clone Infisical
⚙️ Configure .env + secrets
🚀 Run with Docker
🔐 Secure with HTTPS
📈 Monitor with Garmingo Status

Managing secrets is serious business — treat it like core infrastructure.

👉 Monitor your Infisical instance now

How to Install MySQL and phpMyAdmin on Ubuntu (with Monitoring)

Alexander Neitzel — Sun, 11 May 2025 15:31:59 +0000

MySQL and phpMyAdmin are the go-to combo for managing databases in web projects.

Whether you're building something serious or just tinkering, self-hosting your own stack gives you full control — and it’s easier than you think.

In this guide, I’ll show you how to:

Install MySQL on Ubuntu
Secure your database
Set up phpMyAdmin
Add real uptime monitoring — so you know when something breaks

🧰 What You’ll Need

A fresh Ubuntu 22.04 server
sudo/root access
A domain name (optional, but recommended for phpMyAdmin)
10–15 minutes

⚡ Step 1: Install MySQL Server

Update your server:

sudo apt update && sudo apt upgrade -y

Install MySQL:

sudo apt install mysql-server -y

Secure your installation:

sudo mysql_secure_installation

Answer the prompts to remove anonymous users, disallow remote root login, etc.

🔐 Step 2: Create a MySQL User and Database

sudo mysql

Then run:

CREATE DATABASE myapp_db;  
CREATE USER 'myuser'@'localhost' IDENTIFIED BY 'strongpassword';  
GRANT ALL PRIVILEGES ON myapp_db.* TO 'myuser'@'localhost';  
FLUSH PRIVILEGES;  
EXIT;

🌐 Step 3: Install phpMyAdmin

Install required dependencies:

sudo apt install phpmyadmin php-mbstring php-zip php-gd php-json php-curl -y

During setup:

Choose Apache (if prompted)
Configure a MySQL application password

Enable extensions:

sudo phpenmod mbstring  
sudo systemctl restart apache2

Now access it at:

http://your-server-ip/phpmyadmin

🌍 Step 4: (Optional) Set Up a Domain for phpMyAdmin

Point a subdomain (like db.yourdomain.com) to your server’s IP.

Then set up a reverse proxy (e.g. with NGINX) and secure it with HTTPS via Let’s Encrypt.

🛡️ Step 5: Secure phpMyAdmin Access

Protect access by:

Adding .htpasswd authentication
Restricting by IP
Moving it to a non-obvious path (/mydbadmin)

✅ Step 6: Monitor Your MySQL Stack with Garmingo Status

Congrats — your DB stack is running.

But what happens if it goes down?

💡 Don’t wait to find out the hard way. Add uptime monitoring now:

Create a free Garmingo Status account
Add a monitor for:
- http(s)://yourdomain.com/phpmyadmin
- Port 3306 (MySQL)
- Your public IP (Ping monitor)

You’ll get:

Real-time alerts (Slack, Email, Telegram, etc.)
Public or private status pages
Downtime logs & SLA tracking
PDF uptime reports

🆓 100% free plan. No credit card. Instant peace of mind.

👉 Get started here

🧘 TL;DR

✅ Install MySQL
✅ Set up phpMyAdmin
🔒 Secure everything
📈 Monitor it with Garmingo Status

If your database goes down and no one's watching… is it really running?

👉 Start monitoring your stack today

Forem: Alexander Neitzel

Facebook Outage 2021: What You Missed (And How External Monitoring Keeps You Safe)

⚠️ What Actually Happened

🧠 Why Internal Tools Fell Short

✅ Why External Monitoring + Status Pages Matter

🛠️ How Garmingo Status Keeps You Covered

💡 Final Takeaway

What You Can Learn from the AWS US‑East‑1 Outage

⚠️ What Happened

🚨 Why This Matters to You

🔍 How Garmingo Status Protects You

✅ Lessons Learned

🧘 TL;DR

CrowdStrike Outage 2024: Lessons Learned and Why You Need External Monitoring

🔍 What Happened

🌍 Global Disruption

🧠 Why Internal Monitoring Failed

✅ Why External Monitoring Matters

🛠️ Enter Garmingo Status

💡 Final Takeaway

🧘 TL;DR

Lessons from the June 2025 Google Cloud Outage (And How Monitoring Could Have Saved You)

🚨 Lessons from the June 2025 Google Cloud Outage (And How Monitoring Could Have Saved You)

🧠 What Went Wrong

🚫 Who Got Hit

🕵️ Why Monitoring Doesn’t Guarantee Availability, But Helps Fast Recovery

🛠️ How Garmingo Status Protects You

💡 Key Takeaways

TL;DR

How to Self-Host AnythingLLM — Your Own AI Knowledge Base with Monitoring

🤖 How to Self-Host AnythingLLM — Your Own AI Knowledge Base with Monitoring

🧰 What You’ll Need

🛠️ Step 1: Clone AnythingLLM

⚙️ Step 2: Configure the Environment

📦 Step 3: Run with Docker

🧠 Step 4: Load Your Documents

🧪 Step 5: (Optional) Run Ollama Locally

📡 Step 6: Monitor AnythingLLM with Garmingo Status

🧘 TL;DR

How to Self-Host Coolify (Open Source Heroku) — With Monitoring & Free Lifetime Alerts

🚀 How to Self-Host Coolify (Open Source Heroku) — With Monitoring & Free Lifetime Alerts

🧰 What You’ll Need

🛠️ Step 1: Prepare Your Server

📦 Step 2: Deploy Coolify

🌐 Step 3: Add Domain & HTTPS (Recommended)

📈 Step 4: Start Deploying Stuff

🚨 Step 5: Monitor Coolify with Garmingo Status

🧘 TL;DR

How to Self-Host SonarQube for Code Quality Analysis (with Monitoring)

🧪 How to Self-Host SonarQube for Code Quality Analysis (with Monitoring)

🧰 What You’ll Need

⚙️ Step 1: Create a Project Folder

📦 Step 2: Create a docker-compose.yml

🚀 Step 3: Start SonarQube

🔐 Step 4: Secure Your Instance

🔍 Step 5: Start Analyzing Code

✅ Step 6: Monitor SonarQube with Garmingo Status

🧘 TL;DR

How to Self-Host PostgreSQL (with Monitoring)

🧰 What You’ll Need

⚡ Step 1: Install PostgreSQL

🛡️ Step 2: Set a Password for the postgres User

🧱 Step 3: Create a Database & User

🔐 Step 4: Enable Remote Access (Optional)

🌐 Step 5: (Optional) Use pgAdmin for GUI Access

✅ Step 6: Monitor PostgreSQL with Garmingo Status

🧘 TL;DR

How to Self-Host Uptime Kuma (And When You Should Use Something Better)

🧰 What You’ll Need

🚀 Step 1: Project Setup

⚙️ Step 2: Docker Compose Config

🧱 Step 3: Deploy It

📊 Step 4: Add Monitors

🌐 Step 5: Optional – Add a Custom Domain

🤔 But Here’s the Catch

Which means:

✅ The Better Alternative: Garmingo Status

🧘 TL;DR

How to Self-Host Kimai (Time Tracking) on Linux (with Monitoring)

🧰 What You’ll Need

📦 Step 2: Create a `docker-compose.yml`

🛡️ Step 2: Set a Password for the `postgres` User

⚙️ Step 2: Create a `docker-compose.yml`