Self-hosting overview

You can run AppEngine yourself. The same NestJS service that powers appengine.appmint.io is open and packaged for both Docker Compose (one box) and Kubernetes (real production). This page is the decision guide and the high-level architecture.

Hosted vs self-hosted

Both modes run the same code. The differences are in operations:

	Hosted (appmint.io)	Self-hosted
Backups	Automatic, off-site, encrypted	You run them
Upgrades	Continuous, near-zero downtime	You schedule + run them
Scaling	Auto, per-org quotas enforced	You scale
Compliance	SOC 2, GDPR DPA available	Yours to certify
Cost	Subscription	Hardware + ops + license (Enterprise)
Data residency	US/EU regions, AppEngine picks	You control
Custom modules	Limited to plugins	Anything goes
Support	Tiered, SLAs available	Community + paid

Pick hosted if you're shipping a SaaS, a marketplace, an events app, or anything where AppMint owning availability is fine.

Pick self-hosted if you have residency requirements (data must stay in country X), a compliance reason to control the runtime end-to-end, or you're building on top of AppEngine and need to ship the platform itself to customers (white-label, on-prem deals).

What runs

A self-hosted AppEngine deployment has three required services and a handful of optional ones:

        ┌──────────────────┐
        │  AppEngine API   │  NestJS, Node 20+, port 3300
        │  (1..N replicas) │
        └─────┬───────┬────┘
              │       │
       ┌──────▼───┐ ┌─▼────────┐
       │ MongoDB  │ │  Redis   │  data + cache/queues
       └──────────┘ └──────────┘
              │
       ┌──────▼─────────┐
       │ Object storage │  S3-compatible (DO Spaces, R2, MinIO)
       └────────────────┘

Required:

• AppEngine — the NestJS server. CRUD, auth, business modules, workflows, AI proxy.
• MongoDB — system of record. 7.x or later. Replica set for production.
• Redis — cache, BullMQ queues, rate-limit counters. 7.x or later.

Optional but recommended:

• Object storage — file uploads, generated assets. Any S3-compatible service.
• Elasticsearch — full-text search across collections. AppEngine falls back to MongoDB text indexes if missing.
• An SMTP relay — outbound email. Postmark, SendGrid, or your own SES.
• A reverse proxy / TLS terminator — nginx, Traefik, or your cloud's load balancer.

External services AppEngine talks to (depending on which features you enable): Stripe, PayPal, Twilio, vendor LLM APIs, social OAuth providers, EasyPost. None of those are required for core functionality.

Two deployment modes

	Docker Compose	Kubernetes
Best for	Dev, single-box prod, small teams	Real production, multi-tenant
Setup time	Minutes	Hours to days
HA	No	Yes (with replicas + replica-set MongoDB)
Scaling	Vertical only	Horizontal
Updates	docker compose pull && up	Rolling, no downtime
Cost overhead	Negligible	Cluster cost + complexity

Start with Docker Compose to validate. Move to Kubernetes when you need HA, autoscaling, or multi-region.

Sizing the box

Rough sizing for a single-org deployment with moderate traffic (sub-100 req/s):

• AppEngine: 2 vCPU / 4 GB RAM. Memory headroom matters more than CPU — hit >1.5GB heap and the MEMORY_LIMIT env var should be raised.
• MongoDB: 2 vCPU / 8 GB RAM. SSDs essential. Working set should fit in RAM.
• Redis: 1 vCPU / 2 GB RAM, plus enough memory for queue depth peaks.

Multiply replicas to scale. AppEngine is mostly stateless — running 3 behind a load balancer is the common production target. Sticky sessions aren't required (JWTs are stateless, WebSockets use Redis adapter).

For multi-tenant deployments (10+ orgs sharing the cluster), the bottleneck is usually MongoDB I/O. Plan for sharding around 50+ orgs or 1M+ records per collection.

What you have to operate

Self-hosting means owning these things:

1. Backups + restoration. MongoDB dumps daily, off-site, tested-restore monthly. Without this, you have no business in production.
2. Upgrades. AppEngine releases tagged container images. Pull, restart, watch. Schema migrations run automatically on boot — but read the changelog for breaking changes.
3. Secret rotation. JWT secrets, vendor API keys, DB credentials. The shipped defaults in development.env are for dev only — generate fresh ones for prod. See Environment variables.
4. Monitoring. Health endpoints exist (GET /monitoring/health) — wire them to Pingdom/UptimeRobot/Prometheus. See Production operations.
5. Log aggregation. ELK, Loki, or any drain. AppEngine writes to stdout and error.log.
6. Capacity planning. Watch heap, queue depth, MongoDB working set, Redis memory. Scale before saturation.

If you're not equipped for this, the hosted offering exists for a reason.

The license

Self-hosting AppEngine for internal use is free under the included license. Reselling, white-labelling, or bundling it into a product you sell to others requires an enterprise agreement — talk to [email protected].

What's next

• Docker Compose setup — the fastest path to a running instance.
• Kubernetes setup — production deployment.
• Environment variables — every config knob.
• Production operations — runbooks, alerts, backups.