DEV Community: Hasan

How to Self-Host MinIO on Coolify in 2026 (With the Full Admin UI Back)

Hasan — Fri, 26 Jun 2026 12:07:33 +0000

What happened to MinIO

You only need this because it explains a couple of odd choices below:

The community console was stripped to an object browser only. The last release with the full console was RELEASE.2025-04-22.
MinIO went source-only and stopped publishing Docker images around October 2025. The last published image, RELEASE.2025-09-07, carries an unpatched high-severity security hole (a CVE, the public ID for a known vulnerability). The fix shipped in RELEASE.2025-10-15, which was never published as an official image.
The minio/minio repo was archived in April 2026, and Coolify dropped it from the catalog.

The point: the MinIO server still works perfectly. It's the project that's frozen, no patches, no images. So we'll use a patched image someone rebuilt from source, plus a community fork for the UI.

What you'll build

MinIO server is the actual product. Run only this and you have working storage; your apps point at its domain.
OpenMaxIO console is the admin UI. One thing to know: the console was always a separate program from the server. Think of it as a detachable remote control. Old MinIO just shipped it taped to the box. When MinIO stripped the bundled console, the community forked the last full version as OpenMaxIO. So when the UI looks exactly like the MinIO console you remember, that's because it is that console. Just the complete version.

" width="800" height="217">

Let's Start: Create it on Coolify

This assumes Coolify is already running. If it isn't, install Coolify first, then come back here.

In Coolify: open your project, click + New, choose Docker Compose Empty, paste the compose below, and Save. Read the comments. Every odd-looking line is solving a real problem.

services:
  minio:
    image: hasanaboulhasan/minio:RELEASE.2025-10-15T17-29-55Z   # mirror of coollabsio's patched build (see note below)
    command: server /data --console-address ":9001"
    environment:
      - SERVICE_FQDN_MINIO_9000
      - MINIO_ROOT_USER=${SERVICE_USER_MINIO}
      - MINIO_ROOT_PASSWORD=${SERVICE_PASSWORD_MINIO}
      # Do NOT set MINIO_BROWSER=off. It hides the Object Browser inside the OpenMaxIO console.
      # Two more env vars are REQUIRED, but add them in Coolify's env UI (see "Add two URL env vars" below), not here.
    volumes:
      - minio-data:/data
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 10s
      timeout: 5s
      retries: 5

  console:
    image: hasanaboulhasan/openmaxio-console:v1.7.6   # prebuilt; swap for your own if you build one
    environment:
      - SERVICE_FQDN_CONSOLE_9090
      - CONSOLE_MINIO_SERVER=http://minio:9000   # internal hop; plain http on the private net is fine
      - CONSOLE_PBKDF_PASSPHRASE=${SERVICE_PASSWORD_PBKDFPASS}
      - CONSOLE_PBKDF_SALT=${SERVICE_PASSWORD_PBKDFSALT}
    # distroless image has no shell, so a healthcheck can't run and would falsely show "unhealthy". Disable it.
    healthcheck:
      disable: true
    depends_on:
      minio:
        condition: service_healthy

volumes:
  minio-data:

Quick read of what you just pasted. Two services. minio is the server. console is the OpenMaxIO admin UI, an image I built, since OpenMaxIO ships code but no ready-made image. Both live on my Docker Hub on purpose: if an upstream image disappears, this guide still works. Given this whole saga, that's a real risk.

Set a domain on each service

Point a DNS A-record for each subdomain at your server. Then open each service in Coolify and paste its domain into the Domains field. No port needed. The SERVICE_FQDN_MINIO_9000 and SERVICE_FQDN_CONSOLE_9090 lines in the compose already tell Coolify which port each domain maps to.

Paste this into the minio service's Domains field:

https://s3.example.com

And this into the console service's Domains field:

https://console.example.com

Add two URL env vars (this is the big trap)

tell MinIO its public URL. In Coolify, open your resource, go to Environment Variables, and add these two as literal values:

MINIO_SERVER_URL=https://s3.example.com
MINIO_BROWSER_REDIRECT_URL=https://console.example.com

MINIO_SERVER_URL makes signatures validate. It fixes presigned URLs too, same cause. MINIO_BROWSER_REDIRECT_URL is its required companion. Add both in the env UI, not the compose. A Coolify Service Stack doesn't reliably inject literal URL values from the compose file.

Deploy and log in

Hit Deploy. When it's up, open your console domain. Coolify generated your login and shows it right on the service page, an Admin User and an Admin Password. Copy those in.

You should now see the full console: buckets, Identity → Users, Policies, Access Keys, Configuration. Everything MinIO removed, back.

" width="800" height="360">

Done!

That's one service. Real setups run several on one VPS, sharing RAM, SSL, and backups without stepping on each other. That orchestration is the spine of Self Hosting 2.0. This guide is one self-contained piece of it.

Who Writes Faster: Mongo or Postgres? I Ran a 1M Record Experiment to Find Out

Hasan — Tue, 22 Apr 2025 10:25:21 +0000

🚀 I wanted to know: Which database inserts 1M records faster—MongoDB or PostgreSQL?

So I built a benchmark pipeline from scratch—and the results surprised me.

💡 Why I Built This

I've always loved both Mongo and Postgres. But when it comes to high-volume writes...

💭 Which one actually performs better?

To find out, I created a controlled benchmark:

Installed both on Docker locally
Used realistic e-commerce data
Ran single, batch, and concurrent insert tests
Collected performance data: insert speed, CPU, memory

🧪 Step 1: Generate Realistic Data

I used Python + Faker to simulate real-world e-commerce activity:

50,000 customers
50,000 products
900,000 orders

Each record includes nested objects, timestamps, and varied fields. Think: preferences, inventory, shipping, JSON blobs.

python data_generator.py --customers 50000 --products 50000 --orders 900000

🛠️ Step 2: Run the Benchmark

I tested 3 insertion styles for both Mongo and Postgres:

Single inserts – one record at a time
Batch inserts – 100 to 10,000 records per operation
Concurrent inserts – up to 8 threads with batching

Metrics collected:

🕐 Elapsed time
🔁 Records per second
🧠 CPU usage
📦 Memory usage

⚔️ What I Found

🚀 Overall Performance

Database	Avg Throughput (records/sec)
MongoDB	46,012
PostgreSQL	8,900

MongoDB was 5.17x faster on average.

📦 Batch Inserts (Customers)

MongoDB peaked at 78K/sec
PostgreSQL topped at 29K/sec

Batching unlocks massive gains for both—but Mongo scales faster.

🧵 Concurrent Inserts (Orders)

MongoDB: 38K → 110K/sec (with 8 threads)
PostgreSQL: 14.6K/sec (plateaus early)

Mongo loves parallelism. Postgres has limits here.

🔍 Single Inserts

PostgreSQL wins in single insert performance
Its row-level optimization outperforms Mongo’s write path

⚙️ Resource Usage

Postgres used less CPU & memory overall
Mongo burned hotter under concurrency

🧠 TL;DR: Who Wins?

Category	Winner
🏎️ Overall Speed	MongoDB
🎯 Single Inserts	PostgreSQL
📦 Batch Scaling	MongoDB
🧵 Concurrency Scaling	MongoDB
💡 Resource Efficiency	PostgreSQL

🔧 If you need blazing speed, go MongoDB.

🛡️ If you need strict schema & efficiency, go PostgreSQL.

🧪 Try It Yourself (GitHub Repo)

Want to run your own tests?

# Clone the project
git clone https://github.com/hassancs91/mongo-vs-postgres
cd mongo-vs-postgres-benchmark

# Start databases
docker run -d --name mongo -p 27017:27017 mongo
docker run -d --name postgres -e POSTGRES_PASSWORD=postgres -p 5432:5432 postgres

# Generate data
python data_generator.py --customers 50000 --products 50000 --orders 900000

# Run benchmarks
python benchmark.py --data-dir data --output-dir results --postgres-host localhost ...

# Generate report
python report_generator.py --results-dir results --output-file results/case_study_report.md --charts-dir results

📁 You’ll get:

JSON results
PNG charts
Full Markdown report

🔭 What I'm Testing Next

Complex query performance (joins, aggregations)
Updates and deletes
Mixed workloads (read + write)
10M+ record datasets

💬 Let’s Talk

Which database has performed better for you in real-world write-heavy apps?

Have you ever hit a scaling wall with one of them?

I'd love to hear your stories 👇

📥 Full report + visuals + code:

👉 https://github.com/hassancs91/mongo-vs-postgres

🧑‍💻 Happy benchmarking!