Headless CMS

Definitions & benefits

Tools & Concepts

Open source

Features

Authentication

Custom plugins & Marketplace

Webhooks

Multilingual CMS

APIs

Dynamic Zones

User roles & permissions

Content Modeling

Security & Privacy

Use Cases

Ecommerce

Blog

Forum

About Strapi

Life at Strapi

Releases & Roadmap

Events

Community

News

The Tutorials section covers an introduction to Strapi, some advanced technical content, product updates and releases. From basic workaround to in-depth development guides. 

Tutorials

How tos

Get all the latest updates, news and events.

Subscribe to the newsletter 📣

Eight years ago, a trio of freelancing developers students—Pierre, Aurélien, and Jim—set out to solve a pressing problem: traditional CMSs like WordPress weren't cutting it for modern web development, particularly mobile and front-end frameworks that were rapidly evolving. Their solution? Building Strapi, a blend of an API building framework and a CMS, designed to be both robust and adaptable. 

And unlike a monolithic CMS where the front-end and back-end are tightly coupled, Strapi introduces a headless architecture. How does this architecture work together to provide such flexibility? Let's dive into Strapi’s architecture!


## Overview of Strapi's Architecture

Headless architecture here means that the back-end -- your content management and API delivery -- is separate from the front-end presentation. This separation gives developers the freedom to use [any front-end](https://docs.strapi.io/dev-docs/integrations/) they choose, be it [React](https://docs.strapi.io/dev-docs/integrations/react), [Vue.js](https://docs.strapi.io/dev-docs/integrations/vue-js), [Angular](https://docs.strapi.io/dev-docs/integrations/angular), or even frameworks designed for [mobile apps](https://strapi.io/solutions/mobile-cms).

Strapi's architecture is decomposed into several independent but interconnected services. At its core, Strapi is built on a modern JavaScript stack, leveraging Node.js, Koa, and React, among other technologies. It also operates on a modular architecture that houses various registries, a dynamic plugin system, and an extensible API framework.

![Headless Architecture vs Monolithic Architecture](https://api-prod.strapi.io/uploads/Headless_Architecture_vs_Monolithic_Architecture_040b5164e2.png)

## Server initialization and core API zone

The server initialization is the critical bootstrapping phase where Strapi's application server, based on Node.js and Koa, springs into action. It involves setting up the server configuration, initializing the database connections, and preparing the middleware stack that will process incoming HTTP requests.

### Server (node.js) and Middleware

At this phase, [Koa](https://koajs.com/) serves as our main backbone, offering a more direct way to implement server logic with its middleware-centric approach. [Middleware in Strapi](https://docs.strapi.io/dev-docs/backend-customization/middlewares) is crucial; it processes every incoming request, handling tasks such as CORS, body parsing, session management, and error handling. Strapi's middleware is extendable, allowing developers to insert custom logic into the request/response cycle. We also use [Helmet](https://github.com/helmetjs/helmet) for security, and [Knex.js](https://github.com/knex/knex) for talking to the database.

![Strapi Architecture](https://api-prod.strapi.io/uploads/Strapi_Architecture_0f03d820f5.png)

### Policies and hooks registries

Strapi introduces [policies and hooks](https://strapi.io/blog/strapi-internals-customizing-the-backend-part-1-models-controllers-and-routes) as a means to interject custom logic at various points of the application flow. The policies registry holds a collection of functions that can be executed before an action in a controller, acting as gatekeepers. Hooks, on the other hand, provide a way to modify core features or add new ones, enabling integrations and custom behaviors. They act as middleware, but they are tailored to do specific things and don't just act as generic middleware.

### Content API

Within the Core API Zone, we encounter the Content API, which is the essence of Strapi's content management capabilities. This segment deals with the CRUD operations defined by the content types. It consists of controllers that handle the routing and processing of requests, services that encapsulate the business logic, and the entity service that interacts with the database layer.

The flow within Strapi begins at the route, guiding requests to their respective policies. After passing through any Route Policies that apply, the request is handled by Route Middleware for tasks such as authentication or payload processing. The request is then handed off to the Controller, specifically a Koa handler, to orchestrate the next steps.

Inside the Controller, the logic unfolds, tasking the Service to manage business-specific actions. The Service then engages the EntityService for any data manipulation, which, in turn, communicates with the QueryEngine. This engine smartly constructs queries that are executed via Knex.js, ensuring the data interacts seamlessly with the database.

### Plugin API Zone

The Plugin API Zone is the modular heart of Strapi, empowering developers to tailor the CMS to their needs without altering the core codebase. Each [plugin](https://market.strapi.io/plugins) can introduce new functionalities or extend existing ones. They are registered within the system during server initialization, enabling them to integrate seamlessly into Strapi's core. This registry system ensures that plugins are easily accessible and manageable across the application.

Plugins interact with Strapi's core by hooking into the server's lifecycle events, registering new controllers, services, routes, and even UI components. They communicate with the main architecture through well-defined interfaces, ensuring that core updates do not break plugin functionality.

## Database layers and data flow

Strapi's database layer is an abstraction over the actual data storage system, which could be SQL databases like PostgreSQL, SQLite, MariaDB and MySQL.

### ORM and query engine

Strapi has evolved its approach to database interactions, moving away from the Waterline ORM used in earlier versions to a more sophisticated and flexible system in Strapi v4. The platform now employs a custom-built query engine, designed specifically for an agnostic interaction with both SQL and NoSQL databases. This transition aligns Strapi's database interactions more closely with the databases' native query languages. The engine effectively translates queries from Strapi's service layer into the specific commands required by the chosen database, enabling developers to perform Create, Read, Update, and Delete (CRUD) operations using JavaScript. This significant shift from Waterline to a custom query engine marks an advancement in Strapi's capability, simplifying the development process while enhancing its adaptability and performance across various database systems.

### Lifecycle hooks

Lifecycle hooks are integrated into this layer, providing a means to execute custom logic at predefined points in the data handling process, such as before or after saving a record.

When services require data operations, they utilize the entity service's ORM to communicate with the database. This interaction abstracts the complexities of direct database manipulation, providing a unified codebase that can interact with multiple database types. Lifecycle hooks add another layer of interaction, allowing developers to run custom code during data processing events.

## The journey of a request, from start to finish

![Build and request diagram](https://api-prod.strapi.io/uploads/Build_and_request_diagram_49d51310a8.png)

To illustrate how all these elements come together in Strapi, let's trace the journey of a request to create a new blog post:

1. The request begins with the client–a web browser or a front-end framework–sending an HTTP POST request to Strapi's server to create a new blog post.
2. The server receives the request and passes it through the global middleware, which performs initial checks, parses the request body, and sets the stage for routing.
3. The router then takes over, analyzing the request path and method to delegate the request to the corresponding controller for blog posts.
4. The blog post controller springs into action, validating the incoming data against the blog post content type schema. If all checks out, it calls the blog post service.
5. The service, which contains the business logic for creating a blog post, communicates with the entity service to interact with the database.
6. Before the database operation is executed, the entity validator performs one last check to ensure data integrity.
7. Once validated, the entity service uses the ORM/ODM to translate the operation into a database query and executes it, persisting the new blog post.
8. Finally, the service returns the result to the controller, which then sends a response back to the client, confirming the creation of the blog post.

## Wrap up and invitation

Diving into the inner workings of Strapi has been quite the journey. We've peeled back the layers to reveal not just the 'what' but the 'how' and 'why' of our architecture. As we continue to shape Strapi, it's the curiosity and collaboration from developers like you that drive us forward.

Every line of code is an open invitation: come and see how we've built this, tweak it, break it, rebuild it. It's in these interactions that Strapi grows stronger and more attuned to real-world applications.

We're not just handing you a tool; we're handing over the blueprints too. Whether you're integrating a new database or crafting a plugin to extend Strapi's core functionalities, we want you to feel empowered to [make Strapi your own](https://github.com/strapi/strapi).

So, take this architecture deep dive as a starting point. Your insights, questions, and contributions are what make Strapi not just a product but a living, evolving community project. Let's keep the [dialogue open](https://discord.gg/strapi) and the [ideas flowing](https://feedback.strapi.io/). Happy coding!

large_A deep dive into Strapi's Architecture.jpg

medium_A deep dive into Strapi's Architecture.jpg

small_A deep dive into Strapi's Architecture.jpg

thumbnail_A deep dive into Strapi's Architecture.jpg

A deep dive into Strapi's Architecture.jpg

Deep dive into Strapi's Architecture

Paris

Marketing

Vercel has just launched Next.js 14 during their fourth annual conference, and it's full of improvements that make it faster and easier to use. Of course, Strapi’s team was here and a proud sponsor of the event, so we wanted to report back to you. Let's look at the main updates from the Next.js Conference and understand what that means for your Strapi project.

## Key updates in Next.js 14

Vercel calls Next.js 14 their “most focused release." What does this mean for you? Instead of adding new features, the Next.js team has made their existing tools better. Guillermo Rauch, who started Next.js and is the CEO of Vercel, proudly announced that Next.js 14 doesn't have any new APIs.

### Boosting Performance

The main goal has been to speed things up. The team has improved [Turbopack](https://turbo.build/pack), their compiler built with Rust. This has made the local server on `vercel.com` start 53% faster and refresh up to 94% quicker when code changes are made. However, remember that Turbo isn't fully ready yet. To see how it's doing, there's a website called "Are we Turbo Yet?" where you can check out how well it's performing in tests.

### Making things simpler

They also worked on making things easier. They've introduced an experimental feature known as "Partial Pre-rendering." You might ask, "What's different about this from other rendering methods we know?" It's still being tested, but you can try it by turning it on in your configuration file. The goal is to make Next.js simpler for developers.

By using what's called Suspense component boundaries, the system can tell which parts of your app change and which stay the same. It prepares the parts that don't change as HTML and only updates the parts that do change when necessary. This blends the best aspects of both static and dynamic rendering methods.


### Stable Server Actions

Additionally, focusing on simplicity, the Next.js team has made Server Actions a stable feature. This means you can set up a function on the server and trigger it from the client side, like when someone clicks a button or submits a form. This is basically a remote procedure call (RPC), similar to tRPC, but it's built into Next.js, making it easier for developers to use.

## New Next.js learning course

To help developers learn and advance with Next.js, they've updated the API reference documentation and improved search results on their [learning platform](https://nextjs.org/learn). The new course teaches you the basics of Next.js, as well as how to use the App Router, Server components, Server Actions, Authentication, and how to incorporate a Postgres database into your Next.js project..

![next.js14.gif](https://api-prod.strapi.io/uploads/next_js14_e9c1de1bf0.gif)

## Using Strapi with Next.js 14

If you are curious to see how this project can also be built with Strapi and Next 14, check out [this demo project](https://github.com/strapi/strapi-next-14-dashboard-demo/tree/main) that is based on the above Next JS course. It uses Strapi to power its backend instead.  

The project is simple to set up and lets you experience the benefits of combining Next.js with Strapi.

Strapi helps you build a separate API with a full admin panel. If you're looking to reduce development time, get to market quicker, or need a comprehensive backend admin panel for your team to manage content, Strapi is a good choice.

In the repository, you'll find instructions on implementing all the Next.js features with Strapi:
- Full CRUD Functionality
- Pagination and Search
- Authentication 
- Registration
- Middleware for protected routes
- Using Next Cookies

[Project Repo](https://github.com/strapi/strapi-next-14-dashboard-demo)

**Checkout this video that covers project overview and setup**

<iframe
  width="560"
  height="315"
  src="https://www.youtube.com/embed/gG8ud_Bb-x8"
  title="YouTube video player"
  frameborder="0"
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
  allowfullscreen></iframe>

## More Next.js 14: Vercel's leap into AI

Another exciting development from Vercel is about AI. Jared Palmer, who leads AI at Vercel, talked about how Next.js's streaming features are great for AI that generates content. He introduced Vercel's new AI SDK, which makes it easy to work with different large language models (LLMs).

## Conclusion

Next.js 14 is all about refining what is already there for developers, rather than piling on more complexity. The enhancements to speed, rendering, and server actions are all focused on streamlining your workflow. And with Vercel's new AI SDK, we're moving towards a future where AI and web development are increasingly integrated.

Stay tuned to Strapi, as we will continue to update you on these developments and support you as the field of web development evolves. Here's to creating amazing things together!



large_Next.js 14 what's new.jpg

medium_Next.js 14 what's new.jpg

small_Next.js 14 what's new.jpg

thumbnail_Next.js 14 what's new.jpg

Next.js 14 what's new.jpg

Next.js 14 announced at Next.js Conf : What’s new? 

At Strapi, we believe in the power of collaboration, learning, and sharing knowledge. That's why we're launching the new version of the [Write for the Community](https://strapi.io/write-for-the-community) program, with a sharp focus on Community.

## Why a new version for the program?

We currently have a 'Write For the Community' program, where developers can be compensated for the content they create. This program has allowed us to connect with several talented and passionate community members and writers. However, to be transparent, the mixed format of having a community-driven program that proposes compensation has also brought us some challenges. Increasingly, we noticed that we were attracting individuals primarily seeking paid writing opportunities, often lacking Strapi knowledge. As a result, the quality of the submissions deteriorated.

This situation diverted us from our original goal: writing with and for you.

We will continue to collaborate with some of the authors we had the pleasure of meeting during the program to address specific content needs. Nevertheless, our primary focus will be on the Strapi Community: assisting you in your growth and enabling you to share your expertise on topics you are passionate about, while connecting with other developers.

## What is Community Content?

At Strapi, community content holds a special place in our hearts. As an open-source company, we understand the power of collaboration and knowledge sharing. 

Strapi is not just a company; it's a community-driven platform, built with and for its users. With a vibrant community comprising thousands of developers, we believe in harnessing the collective wisdom and experiences of the Strapi Community members. 

Community content matters because it's a reflection of our commitment to empowering developers and enabling them to showcase their expertise. It's a testament to the strength of the Strapi Community and the wealth of knowledge that resides within it. 

By offering developers the opportunity to contribute to our blog, we aim to foster learning, creativity, and innovation, making Strapi a true hub for developers to connect, learn, and grow together. Your insights, ideas, and experiences are what we value the most, and we want the Strapi Community to enjoy them as much as we do.


## What can you write about?


Here's the deal: We want to create more content that helps you to get the most out of Strapi. To make this happen, we're opening up opportunities to share your expertise in five distincts categories:

### Tutorials
In-depth guides that walk through the process of using Strapi for various tasks and various stacks, such as setting up a Strapi project, building custom plugins, or integrating Strapi with other technologies.

### Best practices
Articles that delve into best practices for developing applications with Strapi. Cover topics like data modeling, security, performance optimization, and scalability.

### Use cases and case studies
Real-world stories and case studies showcasing how Strapi was used to solve specific challenges or build unique applications. Include details on architecture, decision-making, and outcomes.

### API integration & frontend development
Write about integrating Strapi with other technologies, frameworks, or services. Cover popular use cases like connecting to a frontend framework (e.g., React, Vue.js).

### Plugin development
Guides on creating custom plugins for Strapi, including how to extend its functionality and add custom features.Share insights on building frontend applications using Strapi as the backend. Discuss various frontend frameworks and how they can be used with Strapi.

## Support and guidance

Our team will be here to support you every step of the way. We'll provide guidance on creating content that packs a punch, making sure your knowledge and stories shine. If copywriting is not your _forte_, we’ll gladly help you with it to make what you have to say shine. 

## Join the program 

If you are ready to become a published author and engage with a vibrant community of fellow developers, share experiences, and learn together in a supportive environment, we are ready for you. Your insights will be featured in Strapi's Community, establishing you as a Strapi expert. Your content will get the visibility it deserves, with our platform drawing over 30,000 monthly views.

Get started in a breeze:

- Choose a category that aligns with your expertise and interests.
- Fill the form on this page. We’ll respond to all requests within a week.
- Craft your content following our guidelines and templates (we'll provide those!).
- Submit your work through the provided [form in this page](https://strapi.io/write-for-the-community).

## Conclusion

Thank you for being part of our incredible Strapi community. Let's make Strapi even more amazing, one article at a time.

Got questions or itching to start? Reach out anytime on #write-for-the-community on our Discord. We can't wait to see what you'll share with us!

Discover the Strapi Write for the Community Program, a platform where developers share their expertise with the Strapi Community