At 09:02, marketing imports 80,000 products. At 09:05, a campaign lands on category pages with cold caches. At 09:07, Strapi is simultaneously writing relations, processing originals, and answering deep-populate requests. The first outage usually looks like a Node memory problem; the root cause is an architecture that assigned admin work, public reads, media processing, and persistence to one replaceable process.
Strapi should own editorial operations and content delivery, not every expensive request on the internet. Put it behind a reverse proxy, store records in PostgreSQL, send media to object storage, and let a CDN handle public files and explicitly cacheable GET responses. That layout is useful because each failure has a named owner: database saturation, cache stampede, upload-worker exhaustion, or a broken webhook consumer.
The production shape
A deployable Strapi diagram has five boundaries. Editors reach the admin application. Strapi reads and writes PostgreSQL. The upload provider writes originals and generated derivatives to S3, R2, or another object store. A CDN fronts media and approved public API routes. Websites and mobile clients consume defined API shapes, either through a backend-for-frontend or directly for simple reads. The reverse proxy terminates TLS, rejects oversized bodies, rate-limits public routes, and forwards only routes Strapi needs.
Keep /admin out of the public traffic path. Put it behind company SSO, VPN access, or an identity-aware proxy; do not treat an internet-facing password form as adequate protection for catalogue, customer-facing copy, and user roles. Public API traffic should not be able to exhaust the same worker pool editors need to save a launch page.
Run Strapi as stateless infrastructure. Replacing an instance must not lose images, cron output, JWT secrets, encryption keys, or configuration. Persistent records belong in PostgreSQL; assets belong in object storage; secrets belong in a secret manager or protected runtime configuration. Pin the Strapi version and package lockfile in the deployment image. An unpinned image tag can turn a routine Friday restart into an unreviewed CMS upgrade.
Postgres is part of the design
SQLite is useful on a laptop. In a shared environment, its single database file turns backups into copy-the-file rituals and makes concurrent write contention someone else's emergency. Start with managed PostgreSQL or an operated instance with automated daily backups, point-in-time recovery where available, and alerting for storage, connections, and replication lag. Test a restore into an isolated database at least once before launch; a backup that has never restored is only a hope.
Use separate database roles. The application account needs only the permissions required at runtime. Migration jobs need schema-change privileges, so keep that credential out of the long-running web service. This limits the blast radius of a compromised process and makes accidental schema changes easier to trace.
Avoid the universal collection type with one JSON field called fields. It postpones modeling work until filtering, role policies, and frontend contracts become opaque. Use components for repeated editorial blocks, relations for entities with independent lifecycles, and first-class columns for values queried by sort, filter, or index. A catalogue needs Product, Variant, Price, and Category records; a page-builder blob cannot reliably answer stock or price queries.
Uploads are not local files
The default local upload provider is a development convenience. In containers, a deploy can replace its disk. With two instances, each instance can have a different media library. With a small ephemeral volume, image conversion can fill the filesystem before the request completes. Configure object storage before the first import, deny public bucket listing, and allow reads through the CDN rather than direct bucket URLs.
Set cache-control by asset type. Fingerprinted derivatives can carry a long immutable cache lifetime; replaceable editorial files need a shorter policy or versioned URLs. Configure CORS only for known frontend origins and restrict upload credentials to Strapi's runtime identity.
Do not transform every original during a traffic surge. Generate the image formats the frontend requires during upload, persist them, and serve them from the CDN. Enforce body-size limits before Strapi receives the request and reject unsupported formats. A 45 MB TIFF should produce a clear validation message, not an out-of-memory restart that interrupts unrelated editors.
Public APIs need a budget
REST and GraphQL are both viable, but neither should accept unlimited pagination, relation depth, or population. Deep populate is a common early failure mode: a page request expands into products, categories, authors, related articles, responsive images, and nested components until PostgreSQL spends hundreds of milliseconds assembling a card grid. Define each frontend query shape, cap page sizes, request only required fields, and inspect slow-query logs before adding CPU or replicas.
Cache public GET responses only where freshness rules are explicit. A marketing page can tolerate a 60-second cache lifetime or a publish-triggered purge; an account endpoint cannot. For static sites, have Strapi publish events trigger route regeneration or invalidate named paths. For personalized responses, either avoid shared caching or include every authorization dimension in the cache key. Missing tenant or user context is how one customer's content appears in another customer's session.
Rate-limit expensive endpoints separately from cheap reads. Search, GraphQL introspection, bulk export, and preview routes have different costs and should not share one broad limit. Monitor p95 latency, 5xx rate, database connection usage, cache hit ratio, and queue depth so the operator can see whether a spike is reaching the CDN, API, database, or media worker.
Publishing is an operational event
Publishing is not merely a row update. A change can affect navigation, search indexes, availability labels, static pages, transactional-email content, and mobile clients. Send lifecycle events or webhooks to the systems that need them, include an event ID and content revision, and make consumers idempotent. A consumer should safely process the same publish event twice; duplicate delivery is normal infrastructure behavior, not an edge case.
Record failed deliveries in a durable queue or failure store with retry status and a visible alert. A webhook lost during a transient timeout creates stale pages that look like editorial mistakes, then consume hours of investigation. Make the failure observable and replayable.
Before launch, load-test public reads with cache hits and misses, restore a production-shaped backup, deploy a clean Strapi instance, and confirm that it can serve existing media without a manual filesystem copy. Give editors roles matching their jobs instead of broad super-admin access. Strapi works well when it remains the system for content operations; the surrounding boundaries keep content available when the site stops behaving like a demo.