July 2026 Summaries

Express.js is a minimalistic and unopinionated web framework for Node.js that provides essential abstractions like routing, middleware, and request/response utilities for building web servers and APIs without the complexity of using raw Node.js HTTP modules. Since its inception in 2010, it has remained a popular choice in the JavaScript ecosystem due to its flexibility, extensive middleware ecosystem, and ease of learning. The recent release of Express 5 in late 2024, following a decade on version 4, introduces enhancements such as native async error handling, updated routing safety, and support for modern Node.js features, while making changes like dropping support for Node.js versions below 18. Express 5 simplifies error handling by automatically forwarding rejected promises to error middleware, and updates the routing engine with [email protected], which introduces new syntax and removes regular expressions from route strings. Despite the emergence of newer frameworks, Express remains relevant for prototyping, education, and scenarios where a vast pool of learning resources and middleware support are advantageous. It is often paired with a headless CMS like Strapi to manage content, allowing Express to focus on custom business logic and integrations, while Strapi handles content model, admin panel, and media management. This combination provides a robust solution for applications requiring both dynamic content management and custom server-side logic.

The tutorial provides a comprehensive guide to building a field service dispatch app using Strapi 5 for the backend and Next.js 16 for the frontend, aiming to solve coordination issues among clients, dispatchers, and technicians. Strapi 5 offers role-based access control, content workflow management, and webhooks, though it requires custom logic for tasks like sorting technicians by proximity. Next.js 16 supports the development of three distinct role dashboards using route groups and server actions. The app functions by allowing a client to submit a service request, which a dispatcher then assigns to the closest technician using a Haversine calculation, and the technician updates the job status in real-time. The system enforces a strict job status pipeline through a middleware and facilitates real-time updates via webhooks, while the user interface remains responsive and role-specific. The tutorial also covers prerequisites, including specific versions of Node.js, Strapi, Next.js, and other tools, and suggests potential next steps like implementing a map view or SMS notifications.

The tutorial offers a comprehensive guide to creating a personal library catalog using Strapi 5 as a headless CMS for backend management and a vanilla JavaScript frontend for displaying data. It details the process of defining Collection Types such as Book, Author, and Category, establishing relationships among them, and incorporating a reusable component for book details. The setup uses SQLite to avoid the need for an external database, and it demonstrates how to seed sample data and consume the Strapi REST API with pagination and relations from the frontend. The tutorial also includes steps for configuring public permissions and API tokens to secure API access, adding a custom search route for enhanced user experience, and implementing pagination on the frontend. It emphasizes the ease of local setup with Node.js and the potential for future enhancements like deploying to production, adding user authentication, and enriching the frontend with a framework like React or Next.js.

The text provides a comprehensive guide on building a translation memory (TM) system using Strapi 5, an open-source headless CMS. It details the setup of a localization workflow backend that utilizes Strapi's built-in internationalization (i18n) support and Document Service API to manage translation units, perform fuzzy matching using the Levenshtein distance, and automate translation capture with lifecycle hooks. The guide emphasizes implementing custom services and controllers to enhance Strapi's functionality for storing and retrieving translation pairs. It also outlines steps for setting up the Strapi backend, creating content types for translation memory, translation units, and localized articles, as well as building REST API clients to interact with the TM backend. Furthermore, it suggests next steps for deploying the TM tool to production, adding content-level TM matching, TMX import/export capabilities, and integrating a frontend dashboard for a complete translation management solution.

A comprehensive guide outlines the process of building a property management portal utilizing Strapi 5 as the backend and a React + Vite setup for the frontend, addressing the complexities of managing rental properties beyond traditional spreadsheets and off-the-shelf tools. By implementing a headless CMS, users can define customized data models and leverage a ready-made API, which this tutorial exemplifies by creating a system to model properties and units as related Collection Types. It includes steps to set up a reusable address component, a custom route for available units, and secure API access with public read permissions and API tokens. The guide also details how to build the React frontend, which fetches data from the Strapi REST API and presents property listings with pagination and image handling. This setup allows for unit-level granularity in real estate directories, with additional insights into deploying the project to production and extending functionality with tenant and lease tracking, advanced filtering, and map integration.

The tutorial provides a comprehensive guide to building an electronic signature platform using a Strapi 5 backend and a React 19 frontend. It explains the legal context of electronic signatures according to the U.S. ESIGN Act and details the technical steps to set up a Strapi backend with a custom Content-Type for tracking document signings, alongside creating custom routes, controllers, and services. The React frontend, scaffolded with Vite, enables users to draw signatures on a canvas and submit them. Signature images are stored in the Strapi Media Library and linked to document entries using the REST API, while the Document Service API serves as the primary interface for content management. The guide also covers the implementation of a custom `/sign` endpoint, user interface components for signature capture, and document listing, ensuring that the entire stack runs locally with SQLite. It concludes with suggestions for deploying to production, adding filtering and search capabilities, implementing user authentication, and ensuring data integrity and audit trails to align with regulatory standards.

The tutorial demonstrates how to create a comprehensive pet care management platform using Strapi and Next.js, integrating a public adoption board, private medical records, and a grooming calendar into a single backend. It details the setup of Strapi 5 for managing interconnected data types like pets, vet records, vaccinations, grooming appointments, and adoption applications, utilizing features like Draft and Publish for controlling data visibility. The guide emphasizes preventing double-bookings with a custom Strapi service that uses the Document Service API to check for time-slot overlaps. The frontend, built with Next.js 16, separates public, SEO-optimized pages from authenticated dashboards, using route groups to manage URL structures. The platform supports role-based permissions, allowing public users to view and apply for adoptions while staff handle sensitive data and scheduling through authenticated access. This integration of technologies ensures a seamless flow of data across different user interactions, enhancing operational efficiency and user experience in pet care management.

The text provides a comprehensive guide on building a custom status page using Strapi 5 for the backend and Next.js for the frontend, highlighting the benefits of self-hosting such as full control over the content model and avoiding per-seat pricing of commercial tools like Statuspage.io. It covers the entire process from setting up the backend with Strapi, including defining content types for services, incidents, and updates, to configuring public read-only permissions and CORS. The guide then transitions to building the frontend with Next.js, focusing on creating TypeScript types, fetch helpers, and computing the overall status to mirror Atlassian's Statuspage features. It emphasizes the importance of a public status page in maintaining user trust during outages and provides detailed steps for setting up the environment, including necessary versions and configurations, to achieve a fully functional and self-hosted status page.

The tutorial provides a detailed guide on building a custom social media scheduler using Strapi 5 as the backend and Next.js 16 for the frontend. It explains how to model social media posts as a Strapi Collection Type, incorporating features like Draft and Publish and a custom publish_at datetime field to enable scheduling. The backend utilizes a cron task to automatically publish drafts based on their scheduled time, while the frontend is a Next.js dashboard that interacts with the Strapi REST API to display scheduled and published posts. The tutorial emphasizes the separation of concerns in a headless architecture, where the backend is responsible for data management and scheduling, and the frontend focuses on rendering. It also covers advanced topics such as error handling, manual scheduling through custom endpoints, and securing API tokens. The guide aims to empower developers to create a Buffer-style tool with full control over content lifecycle management, from drafting through scheduled publication.

In the final part of a tutorial series, the focus is on building a streaming UI for a Next.js application using the Strapi content management system. The tutorial guides users through creating a page route and skeleton, building a block registry and block components, and implementing a DynamicZoneRenderer that enables streaming of content without waiting for Strapi. It emphasizes the use of asynchronous block components wrapped in individual Suspense boundaries to ensure fast loading of page sections, with tag-based cache revalidation and draft previews using Strapi 5's status parameter and Next.js Draft Mode. The tutorial also covers image configuration, caching strategies, and setting up a draft preview mode to enhance development and user experience. The approach ensures that HTML skeletons stream immediately, allowing for independent streaming of data dependencies, which enhances both editor flexibility and visitor experience by not requiring deployments for page rearrangements and reducing server load through efficient caching.

This guide explores the implementation of Dynamic Zones in Strapi 5 with Next.js 16 to create a more efficient content streaming process for web pages, especially those heavily reliant on Content Management Systems (CMS) for marketing purposes. Dynamic Zones enable editors to structure pages using reusable content blocks, but traditionally, rendering these as client components results in request waterfalls that delay initial page loads. By leveraging React Server Components, the guide demonstrates a method where all data fetching occurs on the server, allowing skeleton HTML to be streamed to the browser before the CMS data resolves, thus enhancing page load speed and user experience. The guide details setting up a content model in Strapi, configuring population strategies, and constructing a two-phase fetch system which separates content structure from data, allowing progressive content streaming without client-side requests. The tutorial prepares for a subsequent part that will focus on rendering blocks using Suspense, caching, and draft previews, promising a more seamless integration between the content management and frontend frameworks.

Strapi Cloud is discontinuing its Free plan effective July 1, 2026, due to the realization that the majority of free projects were inactive, resulting in unnecessary infrastructure costs and a subpar user experience due to performance issues. Users with existing free projects have until September 1, 2026, to upgrade to a paid plan or delete their projects, with reminders provided as the deadline approaches. The decision to remove the Free plan allows Strapi to redirect resources towards enhancing the platform for paying customers, with recent improvements including better logs, reliability enhancements, and an upcoming Observability dashboard. The company is also focusing on strengthening the Strapi CMS by improving its performance, integrating advanced AI capabilities, and expanding its enterprise features, which underscores their commitment to offering a robust, paid service.