Skip to main content
Blindly Logo Light

​
Overview

You can self-host Blindly in a few ways:

Docker Compose

Easiest way to run locally or on a single VM — brings up Postgres, Redis, migrates the DB, and starts the Go backend.

Kubernetes

Recommended for production — use the provided deployment manifest with Ingress for TLS and routing.

Mobile App

Use Expo EAS for instant installs via QR, or build/download APKs for Android.

​
Prerequisites

  • Docker and Docker Compose (for local/VM installs)
  • Kubernetes cluster with kubectl access (for K8s installs)
  • Domain and TLS certificate (recommended for production)
  • .env file to supply additional secrets and configuration
The backend requires DATABASE_URL and REDIS_URL, which are set automatically by the Docker Compose setup. Any other environment variables must be provided via a .env file or your orchestrator’s secret management.

​
Docker Compose

id: docker-compose The Compose setup runs:
  • Postgres (with a preconfigured database/user)
  • Redis
  • A migration job (Drizzle) to apply schema migrations
  • The Go backend service (GraphQL + HTTP endpoints, port 9000)

​
Steps

1
Create a .env file in the repository root (blindly/.env) with any required secrets and configs used by the backend. The Compose file already sets:
  • DATABASE_URL to postgres://blindly:blindly_password@postgres:5432/blindly?sslmode=disable
  • REDIS_URL to redis://redis:6379
2
Build and start all services:
docker compose up --build
Or run in detached mode:
docker compose up --build -d
3
Verify the backend is reachable:
curl http://localhost:9000/health
You should see a healthy response if everything is running.

​
Notes

  • The migration job waits for Postgres to be healthy and then applies the Drizzle migrations located under db/drizzle/.
  • The backend exposes port 9000. You can place a reverse proxy (e.g., NGINX) in front if you need TLS and a public hostname.

​
Kubernetes

id: kubernetes Use the provided deployment manifest to run Blindly on a Kubernetes cluster. It includes:
  • Deployment with the backend service (containerPort: 9000)
  • Service exposing port 80 to route to the backend’s 9000
  • Ingress with common NGINX annotations and TLS

​
Review and apply the manifest

The manifest is at: 
# Reference:
# blindly/deployment.yaml
kubectl apply -f deployment.yaml
Key points in the manifest:
  • The Service maps port: 80 → targetPort: 9000.
  • The Ingress contains NGINX annotations:
    • ssl-redirect, body size limits, timeouts, and buffering options
  • TLS is configured for blindly.apps.mellob.in (replace with your domain and secret)
  • The backend image is registry.prod.lyzn.in/blindly — update this to your registry if needed.

​
Environment configuration

Provide environment variables and secrets via Kubernetes Secret + Deployment envFrom or env entries. At minimum:
  • DATABASE_URL — your Postgres connection string
  • REDIS_URL — your Redis connection string
  • Other secrets as required by your .env (see your backend docs)
Add readiness/liveness probes (e.g., HTTP GET /health) and resource limits per your production standards.

​
Mobile App Options

id: mobile-app-options There are three primary ways to get the app running:

​
App configuration

Ensure the app points to your backend host:
  • GraphQL endpoint: https://your-domain/graphql (behind your proxy/Ingress)
  • REST endpoints for specific flows like health, uploads, webhooks
Use your mobile environment handling strategy (app config files or runtime variables) to switch between staging and production.

​
Choosing a path

  • If you’re testing locally or on a single VM, Docker Compose is a great starting point.
  • If you’re running in production, prefer Kubernetes with proper TLS, scaling, and observability.
  • For mobile distribution, Expo EAS QR is the fastest way to share and test. Use APK when you need an installable Android artifact.

Architecture

Learn how the backend, frontend, and database fit together.

Dev Setup

Set up your local development environment.