Hermes Wiki
LocalzDocs/Anti-Lockin-Pattern-for-Startup-Stack

How to Have Anti-Lock-In Pattern for Startup Stack

1) Core cloud building blocks (choose any major cloud)

Compute

  • Container runtime: start with VMs (simple) → later move to Kubernetes (portable).
    • Phase 1 (simplest): 1–3 VMs + Docker Compose
    • Phase 2: Managed Kubernetes (still portable if you keep manifests standard)
  • Load balancer + TLS: a standard L7 load balancer + managed certificates.

Avoid lock-in tip: package everything as containers; keep infra definitions in Terraform.

Object storage (for images, videos, documents)

  • S3-compatible object storage (S3 is fine initially).
  • Put all user uploads here; serve via CDN.

Avoid lock-in tip: use an S3-compatible SDK and keep the storage interface behind your own StorageService abstraction.

Database

  • PostgreSQL (managed service is fine).
    • It's the most portable "default" for marketplace workloads (users, listings, orders, subscriptions, payments metadata).

Avoid lock-in tip: keep SQL migrations in your repo; avoid proprietary DB features unless necessary.

Cache / sessions / rate limiting

  • Redis (managed or self-hosted).
    • caching, rate limits, background job dedupe, ephemeral state.

Networking & secrets

  • VPC / private networking, security groups/firewall rules.
  • Secrets manager (or start with encrypted env vars + later move to a managed secrets tool).

2) Open-source services (self-hostable, portable)

Backend

  • FastAPI + Pydantic (API, validation, OpenAPI contracts)
  • Alembic (migrations)
  • SQLAlchemy / SQLModel (data access)

Background jobs + async tasks

Pick one:

  • Celery + Redis/RabbitMQ (classic, reliable)
  • Dramatiq + Redis/RabbitMQ (clean)
  • Temporal (more complex but very strong for long-running workflows)

Use cases in Localz: image processing, email/SMS dispatch, search indexing, subscription renewal handling, analytics rollups.

Search (optional early, useful soon)

Pick one:

  • OpenSearch (portable, AWS/OpenSearch is managed but self-host exists)
  • Meilisearch (easy, fast, great for marketplace search early)
  • Typesense (similar category)

Use cases: listings search, geo queries, filters, autocomplete.

Observability (do this early)

  • OpenTelemetry instrumentation (portable standard)
  • Prometheus + Grafana (metrics)
  • Loki (logs, optional)
  • Tempo/Jaeger (traces)

Minimal stack that's "enough": OpenTelemetry → Prometheus/Grafana + structured JSON logs.

Reverse proxy / gateway

  • Nginx or Traefik — routing, TLS termination, rate limit at edge.

3) Third-party services (use when they remove real pain)

Authentication (Clerk vs alternatives)

Option A — Clerk (fastest time-to-market)

  • Great developer UX, polished hosted auth.
  • Lock-in risk: medium (auth provider + user identity data model).

Option B — Auth0 / similar hosted

  • Similar tradeoffs.

Option C — Self-hosted identity (lowest lock-in)

  • Keycloak (most common)
  • You own users + flows; more ops burden.

Low lock-in approach (recommended):

  • Use an internal Auth Adapter interface in your backend:
    • get_current_user(), verify_token(), sync_user_profile()
  • Store a local users table keyed by auth_provider_user_id.
  • If you start with Clerk, you can migrate later without rewriting your whole app.

Payments (almost always third-party)

  • Stripe (or equivalent) — subscriptions, invoicing, marketplace payouts
  • Avoid lock-in tip: keep your own internal billing model; treat Stripe as a processor.

Email / SMS / Push

  • Email: Postmark / SendGrid / SES
  • SMS: Twilio
  • Push: FCM/APNs

Avoid lock-in tip: create NotificationService abstraction with providers behind it.

Maps / Geo / Address validation

  • Google Maps / Mapbox
  • Avoid lock-in tip: store lat/long in DB, don't store provider-specific IDs as core identifiers.

Media processing

  • Start with: app worker + ffmpeg + object storage.
  • Scale later with dedicated media pipeline tools.

4) "Default MVP stack" for Localz

Cloud primitives

  • VMs (or managed containers) + Load balancer
  • S3-compatible object storage + CDN
  • Managed Postgres
  • Managed Redis

Open-source

  • FastAPI + Pydantic + Alembic
  • Background jobs: Celery/Dramatiq
  • Search: Meilisearch (early)
  • Observability: OpenTelemetry + Prometheus + Grafana

Third-party

  • Auth: Clerk (start) with adapter layer
  • Payments: Stripe
  • Email: Postmark (simple)
  • SMS: Twilio (only if needed)

5) The key "anti lock-in" rules (follow these and you're safe)

  1. Everything runs in containers (even if you deploy to VMs first).
  2. Terraform for infra + minimal cloud-specific modules.
  3. Abstraction layer for: Auth, Storage, Payments, Notifications, Search.
  4. Use open standards: OpenAPI, OpenTelemetry, SQL migrations.
  5. Keep data model yours: users, billing, listings, orders live in Postgres under your control.
Hermes Wiki