June 2026 Summaries

Strapi's June Community Call highlighted significant developments, including the introduction of a native MCP (Model Context Protocol) server, which is now generally available and allows AI clients to manage content through a unified interface. This server supports various AI applications like conversational content editing and multilingual updates, enhancing Strapi's core functionality with community-driven improvements. Approximately 20% of the merged pull requests were from community contributors, demonstrating strong engagement. Additionally, Strapi v4 has reached its end of life, prompting users to upgrade to v5 for continued security support. The session also covered new features for editors and developers, such as customizable block editors, enhanced media previews, and refined APIs. There was a focus on ensuring security compliance with recent updates, and the team encouraged users to explore new AI-driven workflows using the MCP server. The call concluded with a reminder of Strapi's weekly open office hours and resources like the Strapi Launchpad and Notum's Strapi starter template for further community involvement and project development.

The guide explores building a private mood tracker and journal application using Strapi 5 as the backend for data management and Next.js 16 for the frontend interface. The application allows users to log daily mood scores, attach contextual tags, and write rich text journal entries, with a focus on ensuring data privacy through user-scoped data isolation. Strapi handles data storage and aggregation of mood trends, while Next.js renders the interface and visualizes data using Recharts. Authentication is managed by JSON Web Tokens (JWT), and custom user policies are implemented to enforce data isolation, ensuring only authenticated users can access their own data. The tutorial emphasizes engineering and technical implementation rather than offering mental health advice, guiding developers through setting up content types, enforcing data policies, aggregating mood data, and building user interfaces for mood logging and trend visualization.

The tutorial details the process of creating a gift registry and wishlist platform using Next.js 16 and Strapi 5, highlighting the unique requirement of maintaining the surprise element by not revealing who claimed which gift. It covers setting up Strapi for content management, including modeling content types such as Registry, GiftItem, and Claim, and implementing custom controllers to handle gift claims while hiding claimer identity. The tutorial also explains preventing double-claims using Document Service middleware and configuring public versus owner API scopes. Next.js 16 is used to render public registry pages with dynamic SEO and Open Graph tags and to build an authenticated management dashboard for registry owners to track and manage gifts. The platform allows users to create registries for various events, share public URLs, and manage items through a dashboard, ensuring that claim details remain private to owners for post-event thank-you notes. The guide emphasizes the integration of server actions and optimistic UI updates to enhance user experience, with suggestions for further enhancements and deployment options.

Paul Bratslavsky's tutorial provides a comprehensive guide to building a webinar and workshop registration platform using Next.js 16 and Strapi 5, addressing common operational challenges such as capacity limits, waitlists, and registration confirmations. The platform utilizes Strapi 5's content management capabilities to define event, registration, and speaker content types, while a custom controller in Strapi ensures that registration numbers do not exceed event capacity, promoting waitlisted attendees when spots become available. Next.js 16 is employed to render SEO-optimized event pages, and server-side actions handle attendee registrations. The tutorial also includes instructions for maintaining accurate registration counts with middleware and setting up webhooks for email notifications. The platform is designed to allow organizers to create and publish events, manage speaker assignments, and handle registrations through public-facing pages, with features like automated waitlist promotions and dynamic metadata generation to enhance visibility across social media.

This tutorial provides a comprehensive guide to building a legal case management portal using Strapi 5 and Next.js 16, focusing on secure data handling and role-based access control (RBAC). It addresses the confidentiality needs of law firms by implementing three distinct user roles—Attorney, Paralegal, and Client—each with specific permissions and case-level data isolation. The backend, managed by Strapi, handles data modeling, RBAC, and server-side enforcement, while Next.js renders role-scoped dashboards to ensure sensitive data remains protected. Key features include document access control to prevent exposure of raw media URLs, a status pipeline that validates transitions, and an audit log recording all actions. The tutorial also emphasizes the use of custom policies and middleware for record-level access and status validation, demonstrating how to safeguard data integrity and confidentiality within a legal context. Additionally, it outlines how to set up the frontend to ensure secure authentication and route protection, facilitating a seamless and secure user experience for different roles.

The tutorial provides a comprehensive guide to building an editorial calendar application using Strapi 5 as the backend and TanStack Start for the frontend. It addresses the challenges content teams face with their publishing schedules and introduces a system to manage content from ideation to publication. Strapi handles the content model, editorial status workflow, role-based access control, and scheduled auto-publishing, while TanStack Start offers a type-safe dashboard with calendar and Kanban views powered by TanStack Query for optimistic updates. The application includes features such as role-specific views, an editorial pipeline with custom transitions, and cron tasks for automated publishing. The Kanban board allows users to manage content status with drag-and-drop functionality, and role-based permissions ensure only authorized users can perform specific actions. The tutorial emphasizes the importance of keeping server functions secure and suggests additional enhancements like Slack notifications and content templates for future development.

The text provides a comprehensive guide on building a no-code form builder using Strapi 5's Dynamic Zones and Next.js 16, allowing non-developers to create forms by arranging field components in Strapi's Admin Panel. It outlines the setup of the Strapi backend, including creating form field components, defining content types for forms and submissions, and implementing a custom controller for submission validation. The Next.js frontend dynamically renders forms based on data from Strapi's REST API, with support for server-side rendering and an authenticated dashboard for managing submissions. The guide emphasizes the flexibility and security of this architecture, recommending best practices such as using server-only environment variables and rate limiting to protect against spam. Additionally, it suggests potential enhancements like conditional logic, file uploads, analytics, and webhooks to expand the application's functionality.

The Strapi MCP server, introduced in version 5.49.0, is now generally available, providing a stable and secure way to expose content types as tools accessible by AI agents through a Model Context Protocol (MCP). This development allows seamless integration between Content Management Systems (CMS) and MCP-compatible clients like Claude Code and Cursor without custom integration work. The server supports a range of operations, including listing, creating, updating, and publishing content, all controlled by admin tokens that define the scope of access. Users can enable the MCP server with minimal configuration changes, and while built-in tools cover standard CRUD operations, Strapi also allows the registration of custom tools for more complex workflows, ensuring flexibility and extensibility. The initiative is part of Strapi's ongoing commitment to enhancing developer experiences by supporting community-driven innovations.

In a comprehensive tutorial, Paul Bratslavsky outlines the process of building a sales pipeline app using Strapi 5 and Next.js 16, demonstrating how these tools can streamline the traditionally backend-heavy task of creating a sales pipeline application. The guide covers the creation of data models for deals, contacts, and pipeline stages as Collection Types in Strapi, which are exposed through a REST API, and their integration with a Kanban board in Next.js that allows for real-time updates of deal stages via drag-and-drop actions. It emphasizes the use of Strapi's role-based permissions for secure API access and the implementation of additional features such as filtering, deal value summaries, and role-based access control. The tutorial also provides insights into setting up the development environment, handling API requests securely, and enhancing the application with client-side data aggregation and filtering to improve data visibility and management efficiency.

The text outlines the process of building a compliance management system using Strapi 5, emphasizing its utility for regulated industries by ensuring comprehensive audit trails for content changes. Strapi 5's Enterprise features, such as Audit Logs, Role-Based Access Control (RBAC), Review Workflows, and Content History, are pivotal in tracking who made changes, when, what was altered, and who approved these changes. The system integrates audit logs that capture admin actions, while custom Document Service middlewares expand this tracking to API-level operations. For compliance workflows, RBAC roles ensure controlled content access and separation of duties, while Review Workflows establish approval gates. Content History complements audit logs by providing version snapshots of content, and webhooks are used to push audit data to external systems for long-term retention and real-time notifications. The guide underscores the importance of integrating these components to create a robust compliance pipeline that satisfies regulatory requirements.

In the tutorial "How to Build a Customer and Partner Portal with Strapi and Next.js," Paul Bratslavsky outlines a method for creating a unified portal application using Strapi 5 as a headless CMS and Next.js 16 for handling authentication and routing. This approach allows a single codebase to cater to different user roles, such as customers and partners, by employing role-based content separation. Strapi 5 manages content modeling, permissions, and API delivery while Next.js facilitates role-gated rendering with JSON Web Token (JWT) authentication. The tutorial emphasizes setting up customized Collection Types for different data, configuring roles and permissions, and implementing policies to restrict data access. It also details how to build a Next.js frontend for role-based routing and how to deploy the application using platforms like Strapi Cloud or Vercel. The integration of Strapi's content-type builder, user permissions plugin, and event-driven notifications through webhooks ensures the portal's scalability and maintainability.

The tutorial provides a comprehensive guide on building a crowdfunding platform using Strapi 5 for the backend, Next.js 16 for the frontend, and Stripe for payment processing. It walks through the entire process, from setting up the backend with Strapi for managing campaign content and pledges, to integrating a custom Stripe Checkout endpoint that validates pledge amounts server-side. The tutorial emphasizes the importance of verifying Stripe webhooks to confirm actual payments and updates funding totals in real time. The frontend, built with Next.js 16, utilizes Incremental Static Regeneration to keep campaign data current without redeployment. It also covers the creation of campaign list and detail pages, including a pledge form that triggers the Stripe Checkout process. The tutorial concludes with testing instructions and suggestions for extending the platform with features like Stripe Connect for payouts and user authentication for pledge history.

Between March and June 2026, Strapi introduced significant updates alongside maintaining quality enhancements, marking a pivotal moment in its evolution with the integration of an AI-native MCP server that facilitates programmatic access through secure admin API tokens. This update, from v5.40 to v5.48, also brought in customizability to the Blocks editor, improved live media previews, and stabilized S3-compatible storage, while addressing critical security vulnerabilities with patched CVEs. The release saw substantial community involvement, with about 22% of pull requests contributed by external developers, reinforcing Strapi's open-source ethos. Additionally, the platform's performance received attention with optimizations such as faster database migrations and reduced rerendering, alongside the formal deprecation of the Entity Service in favor of the Document Service. Notably, Strapi 4 reached its End of Life, urging users to upgrade to v5 to benefit from continued enhancements and security updates, underscoring the importance of community collaboration in strengthening the CMS's robustness and adaptability.

The tutorial outlines the process of creating a static open-source project showcase site using Strapi 5 for content management and Astro 6 for static rendering. It addresses common issues faced by open-source maintainers, such as outdated GitHub statistics, by building a site that dynamically synchronizes with GitHub data. The backend, powered by Strapi, models projects, tech tags, and contributors while a custom service fetches live metadata from GitHub, ensuring data accuracy through conditional requests that respect API rate limits. A daily cron task automates data synchronization, and webhooks trigger site rebuilds upon content updates. On the frontend, Astro fetches data at build time to render static HTML, minimizing client-side JavaScript and enhancing performance. The tutorial includes detailed steps for setting up Strapi and Astro, managing data synchronization, and configuring webhooks, alongside building interactive components like a tag filter using Astro's islands architecture. This approach provides a fast, current, and easily maintainable showcase platform that combines structured editorial content with live GitHub metrics.

This tutorial provides a comprehensive guide for building a self-hosted fitness and workout tracking platform using Next.js 16 and Strapi 5, focusing on maintaining user control over their workout data and avoiding subscription fees. The platform is built with two main components: a public exercise library with demonstration images and form guides, and an authenticated workout tracker for users to log their exercises and visualize their progress with Recharts line charts. Strapi 5 is utilized for content management, handling media, and providing custom services for workout statistics, while Next.js 16 leverages server-side rendering for search visibility and server actions for logging workouts. The tutorial covers setting up a Strapi backend to model exercises, workout sessions, sets, and personal records with related content types, and includes a custom service for calculating workout volume, personal records, and streaks. The frontend is developed with Next.js 16, emphasizing a clear separation between server and client components, ensuring that API tokens remain secure and only necessary data is exposed to the client. The tutorial concludes with suggestions for further development, such as deploying to cloud platforms and adding new features like workout templates and social functionalities.

The guide provides a comprehensive walkthrough for building a self-hosted public roadmap and feature request board using Strapi 5 and Next.js 16, aimed at consolidating dispersed feedback into a centralized system where users can submit, vote, and track feature requests. It emphasizes the benefits of self-hosting, such as full data control and avoiding commercial tools' pricing models based on tracked users. The Strapi 5 backend manages user authentication, a custom voting API, and status management through Collection Types, while Next.js 16 handles front-end rendering using Incremental Static Regeneration for fast, fresh pages. The guide details the technical implementation, including modeling data structures, crafting custom API routes, and employing middleware to maintain vote counts accurately. Additionally, it explores Next.js components for rendering a SEO-friendly roadmap with voting functionality, and discusses advanced features like search, filtering, sorting, and on-demand revalidation to ensure data consistency and user engagement.

A comprehensive guide details the creation of a unified customer support portal using Strapi and Next.js, addressing both editorial and transactional content needs. The project utilizes Strapi 5 to manage knowledge base articles and a ticketing system through Content-Types, enforcing ticket status workflows via Document Service middlewares and triggering webhooks for status-change notifications. Next.js 16 is employed to render both public, SEO-optimized knowledge base articles and an authenticated ticket dashboard, with distinct route groups for different functionalities. The guide further explores setting up the backend with PostgreSQL, establishing the frontend with Next.js and Tailwind CSS, and integrating authentication using Strapi's Users & Permissions plugin. By consolidating these functionalities under one backend, teams avoid the complexity and costs of integrating separate systems, while ensuring streamlined content management and support operations. The guide concludes with potential enhancements, including deploying to Strapi Cloud and Vercel, adding full-text search, and building advanced ticket management features.

The tutorial describes the process of building a self-hosted RSS reader using Strapi 5 and Next.js 16, where Strapi manages feed storage and parsing while Next.js renders the user interface. It involves setting up a Strapi backend to model feeds and articles with a one-to-many relationship, using a custom service to parse RSS and Atom feeds via the rss-parser library, and scheduling regular feed updates with cron tasks. The frontend, built with Next.js 16, fetches data from Strapi's REST API to display a sidebar listing feeds and a main panel showing articles. Users can toggle the read status of articles, and the entire system runs on user-controlled infrastructure, storing data in a PostgreSQL database. The tutorial emphasizes the customization and control available through Strapi's features, such as core service methods, custom routes, and the Document Service API, while also highlighting the advantages of using Strapi's built-in scheduling and REST API capabilities without external dependencies.

The tutorial outlines the creation of a construction project management portal using Strapi 5 for backend functionality and TanStack Start for the frontend. Strapi manages content models, role-based access control (RBAC), and document workflows, enabling four distinct roles—Project Manager, Site Supervisor, Contractor, and Client—with tailored permissions. TanStack Start integrates via Strapi's REST API for building an authenticated frontend that supports type-safe routing and data fetching. The architecture emphasizes relational content modeling, where projects, tasks, and documents maintain explicit connections, allowing for precise permission checks and data governance. The portal also employs middleware for task status transitions and handles large document uploads using Strapi's Media Library, ensuring data integrity and adherence to workflow rules without custom server code.

The article provides a comprehensive guide on extending Strapi's Model Context Protocol (MCP) server using plugins to create custom tools for content management. Strapi 5.47+ includes an MCP server, which can be enabled by configuring a single line in server.ts, allowing the use of CRUD tools for content types. However, these tools do not support custom controllers or workflows, which necessitates the creation of custom tools. The process involves using the strapi.ai.mcp.registerTool function to develop custom tools within a plugin, allowing for version control, clean folder structures, and easy sharing. The guide emphasizes the importance of using plugins for managing multiple tools, maintaining portability, and organizing code effectively. It also highlights the challenges and limitations, such as token permissions and the handling of dynamic zones, while providing solutions and workarounds. Additionally, the article covers the integration of tools with AI clients like Claude Code, demonstrating how to set up and use MCP tools for autonomous workflows, and proposes improvements for Strapi's MCP capabilities, particularly in terms of server instructions.

The tutorial provides a comprehensive guide on building a live sports leaderboard using Strapi 5, a headless CMS, integrated with the @strapi-community/plugin-io for Socket.IO support, which eliminates the need for polling by pushing real-time updates directly to clients. The backend is set up with Strapi's Content-Type Builder to model teams and matches, and the IO plugin is configured to broadcast CRUD events over WebSockets. This allows instant propagation of updates to a React frontend, scaffolded with Vite, which listens for these WebSocket events to dynamically update the leaderboard without page refreshes. The tutorial emphasizes the efficiency of using the IO plugin over raw Socket.IO by detailing its declarative configuration, built-in authentication, and support for entity-room subscriptions, which facilitates targeted broadcasting and reduces unnecessary traffic. Additionally, it addresses advanced features like reconnection strategies, entity subscriptions, and authentication, showcasing the plugin's ability to handle multi-instance deployments with a Redis adapter. The guide concludes with suggestions for extending the project, such as adding a standings table or real-time chat, highlighting Strapi's robust capabilities in managing and broadcasting content changes efficiently.

In the article "Building Docs for the AI Era, Part 1: Self-Healing Docs," Pierre Wizla, Strapi's Documentation Architect, introduces a pioneering self-healing documentation pipeline designed to maintain synchronization between code changes and documentation in a headless CMS. This system automatically generates documentation pull requests by analyzing code changes in Strapi's repository, utilizing progressive cost gating with a series of deterministic scripts and lightweight AI models to filter and process relevant changes. Over two months, this approach has resulted in the generation of 22 documentation PRs from 213 scanned, with a 64% acceptance rate and minimal AI costs. Emphasizing human oversight, the system allows for AI to handle initial drafting while human experts ensure accuracy and contextual relevance, thus addressing the industry's challenge of shrinking documentation teams. The pipeline's open-source nature invites adaptation by other projects with separate code and documentation repositories, offering a model for integrating AI into documentation workflows to achieve comprehensive and timely updates.

In this comprehensive tutorial, Paul Bratslavsky guides readers through building an appointment booking platform using Strapi 5, suitable for environments like medical practices, dental offices, and salons. The process involves defining content types for providers, services, and appointments within Strapi 5's content-type system, utilizing the Document Service API, and configuring role-based permissions with the built-in Users & Permissions plugin. The tutorial covers creating custom controllers and services for checking availability and setting up Cross-Origin Resource Sharing (CORS) for a React frontend client. Additionally, it includes steps for setting up a backend using Node.js and SQLite, implementing lifecycle validation to prevent past-date bookings, and configuring permissions for public and authenticated roles. The frontend is developed as a standalone React application that interacts with the Strapi 5 REST API, featuring components for provider selection, user login, and appointment booking. The guide concludes with suggestions for further enhancements, such as deploying to production, adding email notifications, and integrating with other services.

This detailed tutorial explains how to build an insurance claims portal using Strapi 5 for the backend and Next.js 16 for the frontend, allowing policyholders to submit and manage claims independently. The backend utilizes Strapi 5, which provides the content model, REST API, and admin panel needed to handle claims data, while the frontend uses Next.js 16 with Server Components and Server Actions for efficient data handling and form submissions. The guide outlines setting up the Strapi project, configuring collection types, and creating a REST API integration with Next.js, including detailed steps for defining TypeScript types, creating server-side fetch utilities, and building both a claims list and a detailed view page. It also covers the implementation of a claim submission form using React's useActionState and includes instructions for setting up the necessary API permissions, handling data with Strapi's flattened response format, and ensuring fresh data retrieval by disabling fetch caching. The tutorial highlights the use of Node.js LTS, TypeScript, and Tailwind CSS, and suggests future enhancements such as adding authentication, file uploads, and deploying the application to production.

The tutorial provides a comprehensive guide on building a creator monetization platform using Strapi 5, Next.js 16, and the Stripe API, with a focus on integrating Stripe Connect for payment processing and fee distribution. It covers setting up a headless CMS backend with Strapi to manage creators, tiers, and purchases, and creating a frontend using Next.js with routing managed by the App Router. The guide details crucial technical steps such as configuring Stripe Connect Express accounts, handling webhooks with signature verification, and implementing a checkout flow using destination charges for fee splits. Additionally, it emphasizes the importance of secure practices like maintaining private fields, using environment variables for sensitive data, and ensuring webhook signature verification. The platform built allows creators to sign up, list paid tiers, and receive payouts after Stripe onboarding, with all transactions tracked and managed through the CMS. For deployment, the guide suggests switching from test mode to live keys, using HTTPS for live deployments, and considering additional features such as recurring subscriptions or notifications.

The tutorial provides a comprehensive guide to building a wedding vendor marketplace using Strapi as a headless CMS and Next.js for the frontend. It outlines the process of creating a vendor directory that includes features such as category filtering, city-based search, vendor profile pages with portfolio galleries, and authenticated reviews using JSON Web Token (JWT) authentication. The tutorial details the setup of the backend with Strapi 5 and the frontend with Next.js 16, explaining content modeling with Vendor, Category, and Review Content-Types, as well as handling media fields and user-generated content. It also covers deploying the backend to Strapi Cloud and the frontend to Vercel, emphasizes the importance of configuring roles and permissions, and suggests extensions like Stripe Connect for payments and internationalization for broader market reach. Throughout the guide, Strapi's role in managing the data layer and access control is highlighted, demonstrating how it facilitates the development of a complex application without the need for a custom backend.

The text offers a comprehensive guide on migrating a website from Contentful to Strapi using AI tools, specifically highlighting the use of a Claude Code skill that automates much of the process without requiring users to write migration code. It details the motivations for switching from Contentful, a hosted headless CMS with constraints like pricing and data ownership, to Strapi, an open-source alternative that offers full control and customization of content. The guide walks through the entire migration process, from seeding a sample Contentful space to creating a Strapi project, and using the AI skill to map and migrate content types and relationships. It also discusses the implications of Contentful's acquisition by Salesforce, noting potential changes such as pricing increases and strategic shifts away from developer-focused features. The text emphasizes the importance of content ownership and flexibility, advocating for a migration to Strapi to ensure control over data and adaptability in response to industry changes.

The article provides a detailed guide on building a Yelp-style local business platform using Strapi 5, Next.js 16, and Mapbox GL JS, focusing on integrating geo-location features, user contributions, and data flow between server and client components. It outlines architectural decisions necessary for creating a platform with functionalities such as paginated business listings, map-based exploration with clustered markers, and authenticated user reviews. The guide delves into setting up the backend with Strapi 5, including creating content types for businesses, categories, and reviews, and implementing a lifecycle hook for geocoding addresses. It also explains how to expose businesses through a REST API, manage data fetching with Next.js, and render interactive maps with Mapbox. Furthermore, it covers user authentication for review submission, route handlers for server-side requests, and deployment considerations for both Strapi and Next.js applications, while suggesting future enhancements like full-text search and review moderation.

The tutorial provides a comprehensive guide on building a product comparison and review site using Strapi 5 and Next.js 16, focusing on creating essential backend components like product models, category taxonomies, and user reviews with moderation. It outlines the setup of Strapi's Content-Type Builder to model products, categories, reviews, and specifications, and the configuration of role-based permissions to manage content access. The frontend, developed using Next.js, includes routes for product listings, detail pages, comparisons, and a review submission form, leveraging Strapi's REST API for data fetching. The tutorial emphasizes efficient data handling through batched requests and introduces caching strategies using webhook-driven cache revalidation for immediate content updates. Authenticated users can submit reviews, which go through a Draft and Publish moderation pipeline, while lifecycle hooks recompute average product ratings automatically. The guide also touches on transitioning from SQLite to PostgreSQL for production deployments and suggests further enhancements like integrating full-text search or enforcing verified-purchase status.

The tutorial provides a comprehensive guide on constructing a subscription box website using Strapi 5, Next.js, and Stripe, focusing on synchronizing content, billing, and subscription statuses across multiple platforms. Strapi 5 is utilized as the headless CMS for managing subscription plans and customer data, while Next.js 16 is used for developing the storefront. Stripe is employed for handling the checkout process and recurring billing. The guide details modeling subscription data in Strapi, creating Stripe Checkout sessions from Next.js, and maintaining synchronization through webhooks that update Strapi with subscription events from Stripe. A crucial part of the setup involves creating products and prices in Stripe, configuring roles and permissions in Strapi, and building a user dashboard for managing subscriptions. The architecture ensures that Strapi manages content and customer records while Stripe handles payments, with webhooks maintaining consistency between the two. Additionally, the tutorial includes guidance on deploying the application and suggests further enhancements such as per-cycle box variants and customer notifications.

Building a multi-vendor marketplace involves creating a system where vendors can independently manage their catalogs while sharing a unified storefront, a challenge that traditional e-commerce platforms and fragmented solutions often fail to address. Utilizing Strapi 5 and Next.js 16, this tutorial outlines the process of establishing a marketplace with role-based data ownership, flexible product schemas, and JWT-based authentication. Strapi provides a content modeler, a customizable role system, and REST API for communication, while Next.js facilitates server-rendered storefronts and vendor dashboards. Key insights include modeling marketplace data through content types, configuring vendor and customer roles, enforcing vendor-scoped product management via route middleware, and constructing an accessible public storefront. The method emphasizes vendor isolation without complex database setups, ensuring that vendors can manage their products securely through authenticated dashboards, while customers enjoy a seamless browsing experience. The tutorial also highlights future directions, such as integrating payment systems and enhancing search capabilities, to further develop and refine the marketplace.

In the tutorial, Paul Bratslavsky outlines a comprehensive guide for building a documentation site using Strapi 5 and Next.js 16, addressing common limitations in Git-based documentation workflows by providing a user-friendly editor experience for non-developers and eliminating the need for technical writers to interact with Git. The instructions detail how to set up Strapi as a backend to manage structured content, offering features like draft and publish workflows, and role-based permissions, which streamline the documentation process. The guide also explains how to create a Next.js frontend that fetches and displays the documentation content, enhancing the accessibility and usability of the documentation site. Deploying the site involves independently deploying the Strapi backend and Next.js frontend, integrating them through environment variables, and setting up webhooks for automatic updates. This setup allows for flexible content management and multi-channel content reuse, making it an efficient solution for maintaining dynamic documentation sites without the bottlenecks of traditional code-based content management systems.

The tutorial provides a comprehensive guide on how to build a business directory using Strapi 5 and Next.js 16, emphasizing the handling of relational data, such as businesses and categories, within a headless CMS context. It outlines the process of setting up content models in Strapi, creating REST APIs, and integrating them with server components in Next.js for efficient data fetching and rendering. The tutorial assumes familiarity with Next.js 16 and skips introductory content, focusing instead on practical steps like setting up a local development environment, managing content through Strapi's Admin Panel, and deploying the application using Strapi Cloud and Vercel. Key features include category filtering, server-rendered search results, and editable business entries without code intervention, all aimed at enhancing SEO and user experience. Additionally, it touches on potential post-launch enhancements, such as map views and user-submitted content, and highlights the importance of configuring permissions and caching strategies for optimal performance.

The tutorial provides a comprehensive guide to building a social network with activity feeds using Strapi 5 and Next.js 16, focusing on creating a personalized, recency-ordered timeline for users to see posts and follow events from those they follow. It covers the critical aspects of modeling a social graph, automatically generating activity records, and efficiently querying these records at read time. Strapi 5 manages the content model and backend operations, utilizing Document Service middlewares for automatic activity logs, while Next.js 16 handles authentication and frontend rendering through a custom API endpoint that queries follow relationships for personalized timelines. The tutorial also highlights the use of Node.js for server-side operations, JWT for secure authentication, and the importance of proper indexing and pagination for performance. Additionally, it discusses potential scaling strategies and suggests areas for further enhancement, such as integrating real-time updates and expanding the activity types.