PRODUCT ENGINEERING / CONNECTED BUSINESS SYSTEMS
OmnistuSTUDIO / SERVICESStart a project

Content engineering / Strapi

Strapi development.
Content models, custom APIs and publishing controls.

Headless CMS scope for teams connecting structured content to websites, mobile apps and internal tools. Define the editors, API consumers and operating boundaries before extending the backend.

Discuss Strapi requirements โ†—
Contents ยท Strapi

Start with content structure and access, not an empty installation.

Strapi combines a Node.js backend and an administration interface. A development engagement can define collection and single types, reusable components, dynamic zones, relations, localisation and editorial tasks, then extend APIs and connect consumers. The CMS is not the rendered website or a complete mobile application.

Map who creates, reviews, publishes, translates, reads and deletes each kind of content. Separate administrator access from content-consumer authentication and public API permissions. List custom business rules, external accounts, data ownership and the receiving team before choosing plugins or infrastructure.

A CMS can supply editorial descriptions while commerce or another application owns price, stock, identity or transactions. Define those boundaries explicitly. Generated endpoints, a working admin login or a platform badge do not establish a secure or complete application.

Open source does not settle every right or maintenance duty.

Distinguish the platform licence from custom-code rights, paid features, plugins, assets, content and hosting terms. Verify the actual edition and dependencies. Self-hosting gives infrastructure responsibility as well as control; it does not create a universal zero-lock-in or ownership guarantee.

Agree delivery of source/history, content-type schemas, custom plugins, controllers/services, migrations, API documentation, sanitised fixtures and deployment scripts. Name database, storage, hosting, domain and provider owners. Keep secrets in a secure route rather than ordinary source archives or screenshots.

Confidentiality, IP assignment, white-label use, support, capacity, cancellation and exit need written terms. A full source tree is not proof another team can operate it immediately. Rehearse setup, a release and restoration with the receiving team. No fixed NDA turnaround, included support window or automatic transfer of every third-party right is offered here.

Compare the same content and editorial work across platforms.

Compare Strapi, Contentful, WordPress and Drupal using representative models, relationships, permissions, locales, preview, hosting and receiving-team skills. Avoid declaring one the default winner or assuming a managed platform removes all development work.

Compare the Contentful, WordPress and Drupal service scopes. A page builder such as Wix solves a different editing need from a content API. Current licence, plan and operating costs need their own check; historical plugin totals or quota tables do not establish present fit.

Seven decisions before a Strapi engagement.

What does custom work include?

Model collection/single types, components, dynamic zones, relations and validation. Scope custom controllers, services, policies, middleware, admin/server plugins, media, localisation and API permissions. Distinguish configuration from custom code and demonstrate editor and consumer tasks before calling the CMS finished.

How does it work with Next.js or mobile?

Websites and mobile clients consume content through APIs and render it themselves. Next.js static/server rendering and cache/revalidation, React or other web consumers, and React Native, Flutter or native apps need separate compatibility, authentication, preview and release designs. A content update may avoid a new binary, but only when the existing client understands the data and its cache/update behaviour is tested.

A publish webhook can start invalidation or rebuild work. It does not prove every page or app receives the new content at the same moment. Trace shared references, lists, locales, offline clients and retries before making freshness claims.

Self-hosting or Strapi Cloud?

Compare region, runtime, database, persistent storage, network access, backups, scaling, monitoring, support and actual plan limits. Self-hosting needs an operating team. Managed hosting still leaves application code, plugins, permissions, content and external consumers to maintain. Verify plan-specific features and terms rather than assume every edition includes SSO, history or review workflows.

What does a legacy upgrade involve?

The inspected official migration guide records Strapi v4 end of life and a final later v4 release. Inventory the exact installed version, custom code, plugins, APIs, database and consumers, then use the supported upgrade procedure on an isolated restored copy. Codemods update some code; they do not prove custom logic or plugins are compatible.

Review Entity Service to Document Service changes, documentId, flattened responses, status/locales and any temporary compatibility mode. Reconcile data and API contracts after first-start database migrations. There is no automated v5-to-v4 downgrade; recovery requires a matching pre-upgrade database/code/dependency snapshot.

Which CMS should be selected?

Use the receiving team, editorial process, integration boundaries and maintenance obligations to compare platforms. Self-hosted control can be valuable but creates work. A managed subscription can be useful but has limits and exit tasks. Traditional theme editing and headless delivery are different requirements, not measures of company size.

How is API performance investigated?

Measure representative published queries and the database, relations, payloads, indexes, media and consumer cache. Bound populate depth and page sizes; inspect GraphQL depth and result limits. Add a chosen cache only with a tested invalidation and private-data design. Profile a production-like release, including cold cache and failures, not only development mode or a warm successful query.

Freelancer, internal team or delivery company?

Match continuity and skills to the work. A custom field or contained plugin fix differs from content design, API work, multiple clients and hosting operation. Name architecture, backend, frontend, QA and operations reviewers. Ask for attributable examples, reproducible source and a restore/release rehearsal rather than rely on a team label or anonymous proof.

Custom endpoints must preserve access and output boundaries.

Controllers, services and middleware have distinct jobs

Use content types and components for structure, controllers for route actions and services for reusable logic. Policies can reject access; route/global middleware control request flow. Document Service middleware operates around document methods. Do not put every business rule in a frontend or assume one REST controller customisation also protects GraphQL resolvers.

Current backend guidance recommends Document Service middleware for document-level behaviour rather than reaching directly into database lifecycle hooks without need. Inventory every write path, including admin, REST, GraphQL, imports and custom jobs. Test the intended hook/event behaviour for the installed release rather than assume one change produces one callback.

The source publish controller is not a complete authorised endpoint

The original example narrows find to published entries and delegates to the generated controller. It also adds a publish action calling Document Service with a documentId and requested locale. That second action is not complete merely because the method exists: a route, authenticated actor, allowed publication authority and safe response handling must be designed and verified.

Official documentation explicitly says Document Service is a data-access layer unaware of user permissions or field visibility and returns unsanitised data. Results can include private fields, passwords or restricted relations. Built-in API sanitisation does not automatically cover a custom controller returning direct results. Reuse the core controller where suitable or apply documented contentAPI validation/sanitisation with the correct schema and auth context.

Document identity, draft and locale need explicit scope

Strapi 5 uses documentId for the document, while numeric id identifies a physical locale/version record. Entity Service is deprecated in favour of Document Service. Do not silently use a numeric record id as a stable external document identity.

Document Service read methods can default to draft content in the default locale. Explicitly select the intended status and locale in public consumers and jobs, then verify access and output. Publish/unpublish/discard methods require Draft & Publish on the content type. Published documents also have draft counterparts, so a draft count is not a count of only never-published content.

REST and GraphQL require bounded queries

REST controllers and GraphQL resolvers have distinct extension routes. Review public-role rules, API tokens, user authentication, private fields, relations and populate permissions for both. GraphQL needs its official plugin and configuration; it is not active merely because a model exists.

Current plugin documentation says query depth and maximum page size can be unlimited unless set. Configure depthLimit and maxLimit for the workload, plus appropriate pagination and resolver access. The old amountLimit option is ignored in Strapi 5, so a familiar-looking legacy config is not proof a limit is enforced. Test actual rejected or bounded requests.

Publication events start work; they do not prove synchronisation.

Built-in webhook events can cover content and media actions, with additional features depending on edition. Publishing can save a draft before emitting publish, so a single editor action can generate multiple events. documentId identifies the document while id can change with version/locale operations. Do not deduplicate solely on a physical record assumption.

The inspected webhook guide documents auth headers and recommends sender/receiver signature verification. A topic name alone is not authentication. If using signatures, implement both sides and verify the raw body, timestamp and allowed context; the presence of receiver pseudocode does not prove built-in outgoing requests are signed for your setup.

Redis, a cache plugin, CDN media, reverse proxy and frontend revalidation are separately selected tools. Define ownership, expiry, invalidation, retries and acceptance for each selected component. Measure propagation and cache behavior on the actual channels rather than assume simultaneous updates or guaranteed latency.

Three engagement shapes with written acceptance.

Name owners and define milestones, demonstrations, billing, change control, cancellation and handover.

Six acceptance areas before CMS handover.

Test accessibility and SEO in the actual front end and authored content. A documented check has a scope; it is not a blanket security, privacy or accessibility certificate. No live API, completed handover, support promise or production deployment is demonstrated by this planning page.

Choose the runtime and operating tools for the actual release.

The source names AWS EC2/RDS while current deployment documentation excludes some cloud-native database services. Do not infer that any managed SQL offering is supported from the source stack label. Verify the exact database product/version and provider support before selecting it. MongoDB/NoSQL is not a supported substitute under the inspected requirements.

This is an option inventory, not a preinstalled bundle or permission for paid hosting, external tracking or account changes. Check supported Node/database versions and plugin compatibility again for an actual deployment.

Code deployment can change data, not only the admin interface.

Build the administration bundle for production and run the server with supported production configuration. The static admin output is not the whole CMS runtime. A Node process, supported database and persistent upload storage still need operation, access and recovery.

The inspected deployment guide warns that starting Strapi with changed schemas alters the database, and removing a content type can drop its table. Review schema changes and recovery before the process starts. Content types travel with code; editor content needs a separate supported data-management process.

Keep staging and production databases and media storage isolated. Maintain approved environment secrets across releases instead of casually regenerating values that invalidate sessions or API tokens. Inject credentials through the intended secure configuration route, not a committed environment file. A successful admin build or health response is not a full content/access/integration acceptance test.

Import and upgrade require a tested restore route.

Inventory source models, content, users/roles, media, relations, languages, URLs and consumer contracts. Rehearse WordPress, Contentful, Sanity, Drupal or custom-source mapping with supported tools and scripts. Reconcile identity, relationships, draft/publication states, assets and exceptions as well as counts; do not promise a complete audit trail or zero loss.

Official data-import documentation warns import deletes existing destination data, including database and uploads, before restoration. Source/target schemas must match. Admin users are not restored, so createdBy/updatedBy are empty in the restored instance. This is not a harmless merge command or a full ownership-preserving migration.

The same guide warns deleting media records during import can permanently delete remote provider assets, affecting other environments sharing storage. Use isolated buckets/accounts and prove recovery before a rehearsal. An environment label alone does not isolate the underlying storage.

For v4-to-v5, preserve a pre-upgrade code/dependency/database/media snapshot and test codemods, plugins, document identity, response shape and first-start migrations. Official guidance says there is no automated downgrade. Restoration must use the matching earlier state, not merely switch the package version. Redirects and rendering checks help changed URLs but cannot guarantee ranking retention.

From content brief to an operated API service.

Content readiness, external access, review and wider mobile/payment approvals can affect delivery. Those dependencies are not automatic CMS work. Agree current milestones and responsibilities; source fixed timelines and first-endpoint promises are not offers.

Scope implementation separately from licences and operation.

Request current itemised written quotes, assumptions and exclusions. Verify the actual edition and hosting terms rather than infer no cost from open source. Source sample prices, project ranges, durations, retainers and no-surprise-invoice guarantees are not current commitments.

An illustrative regional media content platform.

Consider a publisher replacing a legacy WordPress workflow and a separate mobile content database. This is a requirements scenario, not a verified Omnistu delivery, publishing-time improvement, response-time result or client testimonial.

The useful depth is the model inventory and acceptance design. Source schedule, language/editor counts, latency, support and claimed publishing gains are not proof of completed work.

Strapi delivery review and handover.

Agree the implementation boundary, deliverables and acceptance checks in the project scope. Include the source and configuration to be handed over, third-party dependencies, account ownership and the receiving owner's installation and operating walkthrough. Review the selected work at the agreed milestones, with unresolved items recorded before release.

The handover can include reproducible builds, reviewed schemas, input/output tests, published/draft isolation, event traces, database/media restore and the receiving team completing an authorised release. Confirm current contracting identity, rights, commercial terms and support scope directly.

Turn sector labels into editorial responsibilities.

Questions to settle before Strapi work.

Can an existing project be extended?

Audit version, custom code, plugins, models, database/media, public permissions, tokens and consumers. Separate an upgrade from the desired feature where useful. Rehearse changes on isolated restored data before production.

Can the website be included?

Define the rendered frontend separately from the Strapi server/admin. Agree dynamic-zone components, preview, authentication, SEO fields, cache and publish propagation. A connected endpoint is not a completed website or mobile app.

Does it support both REST and GraphQL?

REST is generated for content types; GraphQL requires its official plugin and configuration. Test route/resolver access, query limits and contract shape. Neither automatically authorises a custom publish mutation or guarantees safe output.

Is it good for SEO?

The front end and editorial content determine crawlable rendering, metadata, canonical URLs, redirects and performance. Scope fields and rendering/tests without promising rankings. A CMS platform choice alone is not an SEO result.

What source, confidentiality and support are included?

Agree source/history, schemas, custom plugins, API notes, secure environment setup, confidentiality, rights and operation in writing. No zero-lock-in, immediate takeover, included support window or response-time guarantee is verified here.

What does hosting require?

Verify supported runtime/database, persistent media, resource needs, deployment, secret handling and backups for the exact release. Managed hosting terms and paid feature availability are separate checks, not implied entitlements.

Platform references used for technical checks.

Official documentation checked on 17 November 2026. Re-check exact versions, plugins, edition and provider terms before implementation. Reference examples are not proof of an operating system.

Bring the content rule or API workflow that needs to change.

Describe the editors, models, channels and existing platform. Keep permissions, publication, consumer compatibility, data/storage isolation and receiving-team operation visible before agreeing implementation.

Discuss your Strapi scope โ†—