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 📣

Feeling overwhelmed by the multitude of web development tools and wondering which is the best fit for your project? 

In this blog post, we'll delve into the differences between Strapi, a popular headless CMS, and several back-end frameworks to help you make an informed decision depending on your project needs. By exploring the core concepts and advantages of each, you'll be better equipped to choose the right tool for your project. 

Let's dive in and start by understanding what a headless CMS is and how Strapi fits into that category.

## What is a Headless CMS?

A headless CMS is a modern solution for managing and delivering content across a diverse range of platforms, breaking free from the confines of traditional content management systems. By separating content creation from content presentation through an API-driven approach, a headless CMS enables you to seamlessly distribute and adapt your content to websites, mobile apps, and IoT devices. A headless CMS, such as Strapi, allows you to embrace the power and flexibility of a decoupled architecture and revolutionize your content strategy for the ever-evolving digital landscape. 

### Benefits of Using a Headless CMS

#### Flexibility and Scalability
- Future-proof your content strategy: A headless CMS adapts easily to new technologies and platforms, ensuring your content remains relevant and accessible.
- Choose your front-end: Enjoy the freedom to use any front-end technology or framework, empowering you to create unique user experiences tailored to your target audience.
- Scalable infrastructure: With a headless CMS, you can easily scale up or down depending on your traffic and content requirements, providing cost-effective and efficient solutions.
	
#### API-driven Content Management
- Consistent content across platforms: Centralize your content management to maintain consistency across all platforms through a single API, ensuring a cohesive brand presence.
- Faster content delivery: A headless CMS efficiently delivers content to different platforms, reducing loading times and improving user experience with optimized performance.
- Streamlined content updates: Update content once in the CMS and automatically propagate changes to all connected platforms, saving time and resources by eliminating manual updates.
	
#### Easier Content Distribution Across Multiple Platforms
- Omni-channel publishing: Reach a wider audience by effortlessly distributing content to various platforms and devices, from websites and mobile apps to digital signage and IoT devices.
- Simplified content reuse: Easily re-purpose and adapt content for different platforms and contexts without duplication, ensuring a consistent message across channels.
- Enhanced collaboration: Facilitate collaboration between teams working on different platforms by managing content in a unified system, streamlining workflows, and improving productivity.

### Why Strapi?

#### Key Features and Advantages
- Embrace open-source flexibility: Strapi stands out as a free, open-source solution, allowing you to host on your own infrastructure for complete control over data and customization or opt for the convenience of the new [Strapi Cloud](https://strapi.io/cloud). Whether self-hosted or on Strapi Cloud, Strapi ensures a professional and efficient content management experience tailored to your project goals.
- Customization and extensibility at your fingertips: Take advantage of Strapi's plugin system and comprehensive API to extend its functionality and adapt it to your project's unique requirements.
- Prioritizing security and performance: Built with security best practices in mind, Strapi also offers performance optimizations to guarantee swift and reliable content delivery.
- Streamlined user experience: Strapi's intuitive admin panel simplifies content management for developers and non-technical users, promoting seamless collaboration.

#### Real-World Use Cases
- **E-commerce websites**: Efficiently manage product catalogs, descriptions, and images to create an exceptional online shopping experience. 
- **Telecom and media platforms**: Streamline and distribute diverse content and services, including news articles, images, and multimedia communication, seamlessly across websites, mobile apps, and other digital channels. Kyivstar, a prominent leader in the mobile communications market and fixed Internet services in Ukraine, [use Strapi to manage its website and mobile app](https://strapi.io/user-stories/kyivstar) effectively, serving 10 million users actively engaging with the platform monthly.
- **Corporate websites and blogs**: Maintain a consistent brand image by easily managing and updating company news, blog posts, and marketing materials across platforms. An illustration of this is the success story of Sonos, an American developer and manufacturer of audio products, [using Strapi to launch a multilingual website in 8 new markets](https://strapi.io/user-stories/sonos-pixel-alliance). 
- **Educational platforms**: Distribute educational resources, courses, and multimedia content to students easily across various devices and platforms.

## Back-end Frameworks: An Overview

Back-end frameworks serve as the backbone that powers communication between front-end applications and databases, managing data processing, business logic, and server configuration. 

These frameworks offer developers a set of established conventions, tools, and libraries, allowing them to concentrate on developing unique features and functionality rather than building everything from the ground up. 

Developers can accelerate the development process by employing a back-end framework, improving scalability, and maintaining a well-organized codebase.

### Benefits of Using a Back-end Framework

#### Faster Development
- Accelerate your project: Back-end frameworks provide pre-built components and a clear structure, streamlining development by minimizing repetitive tasks and boilerplate code.
- Swift learning curve: With extensive documentation and a supportive community, developers can rapidly learn and adapt to the framework's conventions and best practices.

#### Reusability and modularization
- Organized code: Back-end frameworks foster modularization and reusability, guiding developers to create clean, organized, and maintainable code.
- Simplify updates and maintenance: The modular nature of the code makes it more manageable, enabling easier updates, debugging, and maintenance, ultimately saving time and effort.
	 
#### Built-in Tools and Libraries
- Streamlined toolset: Back-end frameworks equip developers with built-in tools and libraries, facilitating tasks like database management, authentication, and caching.
- Reliable performance: Utilizing a back-end framework allows developers to take advantage of tried-and-tested libraries and tools, ensuring dependable and consistent application performance.

### Some Popular Back-end Frameworks

#### Express.js
- Lightweight and efficient: Express.js, a popular Node.js framework, is known for its minimalistic design and impressive performance capabilities.
- Vast ecosystem: As part of the Node.js ecosystem, Express.js boasts a wide range of plugins, libraries, and an active community for support.

#### Django
- Powerful and versatile: Django, a robust Python-based framework, simplifies complex web application development with its comprehensive tools and features.
- Security-centric: Django emphasizes security, providing built-in protection against common vulnerabilities such as cross-site scripting and SQL injection attacks.

#### Laravel 
- Sleek and feature-packed: Laravel, a PHP framework, merges elegant syntax with potent tools, making it a top choice for contemporary web application development.
- Expedited development: Laravel's extensive ecosystem, featuring tools like Laravel Forge and Laravel Nova, accelerates development by automating repetitive tasks and streamlining common processes.

## Comparing Strapi to back-end frameworks

| Category               | Strapi                                            | Backend Frameworks                                  |
|------------------------|---------------------------------------------------|-----------------------------------------------------|
| Content Management     | Built-in content management features              | Custom content management solutions                |
| Customizability        | Plugin system and extendable API                  | Customization options and community-driven libraries|
| Learning Curve         | User-friendly interface                           | Coding and development process                      |
| Performance & Scalability | Performance optimizations & scalability considerations | Various performance and scalability options         |


#### Content Management

Strapi offers built-in content management features, making it easy for users of all skill levels to create, edit, and manage content. In contrast, back-end frameworks require developers to build custom content management solutions by integrating libraries and writing code, which demands more effort and expertise.

#### Customizability

Strapi's plugin system and extendable API allow developers to enhance its functionality to meet their project's specific needs. Back-end frameworks also offer high customizability through various libraries, tools, and community-driven resources. However, building unique applications with back-end frameworks may require more time and expertise compared to Strapi's built-in features.

#### Learning Curve

Strapi's user-friendly interface simplifies content management tasks for developers and non-technical users. Back-end frameworks typically have a steeper learning curve, as developers need to understand the framework's conventions, libraries, and tools to build custom solutions.

#### Performance & Scalability

Strapi ensures fast and reliable content delivery with its API-driven approach, caching, and performance optimizations. Back-end frameworks also offer various performance and scalability options, but achieving optimal performance requires thorough planning, configuration, and monitoring.

## Choosing the Right Tool for Your Project

Selecting between a headless CMS and a back-end framework is a crucial decision that hinges on various factors, such as your project's unique requirements, your team's expertise, and the resources available. This section will delve into these factors and provide insights into scenarios where Strapi or a back-end framework might be the more fitting choice. 

### Factors to Consider

1. Project Requirements and Objectives: Start by pinpointing your project's main objectives, and determine which features and functionalities are vital to achieving those goals. This will guide you in deciding whether Strapi's built-in content management and API-driven approach or a tailor-made back-end solution better aligns with your needs.
2. Team Expertise and Experience: Assess your team's proficiency in different programming languages, frameworks, and technologies. Opt for a solution that matches your team's strengths and experience, guaranteeing a more efficient development process.
3. Budget and Resources: Weigh the time, money, and resources allocated for your project. Strapi is often a cost-effective solution for content-centric projects. At the same time, a custom back-end framework might be more appropriate for intricate, resource-demanding applications.

### Scenarios Favouring Strapi
1. Content-heavy applications: Strapi shines in managing and delivering content across numerous platforms, making it the go-to choice for projects centered on content, such as blogs, news websites, and e-commerce platforms.
2. Multi-platform Content Distribution: Strapi's headless architecture and API-driven approach streamline content distribution across a variety of platforms and devices, making it easier to reach a broader audience.
3. Quick Setup and Ease of Use: Strapi boasts a user-friendly interface and built-in content management features, enabling swift project setup and simplifying content management for developers and non-technical users alike.

### Scenarios Favouring a Back-end Framework
1. Complex and custom application logic: Back-end frameworks offer greater flexibility in designing and implementing bespoke application logic, making them a perfect fit for projects with distinct and intricate requirements beyond content management.
2. Integration with Other Systems and Services: If your project necessitates seamless integration with various external systems, services, or APIs, a back-end framework may offer better control and adaptability in managing these integrations.
3. Full Control Over Development and Architecture: Back-end frameworks empower developers with complete control over every facet of the application's architecture and development process, ensuring that the end product perfectly aligns with their exact vision and requirements.

By meticulously considering these factors and evaluating your project's needs, you can decide between Strapi and a back-end framework, ultimately selecting the ideal tool to propel your digital project forward.

## Conclusion
This article delves into the key differences between Strapi, a headless CMS, and back-end frameworks. Strapi shines in its built-in content management features, ease of use, and API-driven approach, making it an excellent choice for content-heavy applications and multi-platform content distribution. On the other hand, back-end frameworks can offer greater flexibility and control over development and architecture, catering to projects with complex requirements and custom application logic.

_It's important to note that Strapi can be used in conjunction with back-end frameworks, combining the power of both tools to create robust and flexible applications that cater to your specific needs._

Choosing the right tool for your project cannot be overstated. The success of your digital project hinges on aligning your choice with your unique needs, resources, and objectives. Considering the factors outlined in this article, you can make an informed decision to propel your project forward and maximize its potential.

We encourage you to further explore Strapi and the various back-end frameworks available. Each tool has its strengths and merits. By thoroughly investigating its capabilities, you'll be better equipped to make the right choice for your project. Remember, the right tool can make all the difference in ensuring a smooth and successful development process.

[![Strapi Demo](https://d2zv2ciw0ln4h1.cloudfront.net/uploads/Strapi_Demo_be3d83686a.png)](https://strp.cc/44RXrFP)

Learn the differences between Strapi, a popular headless CMS, & back-end frameworks to help you make an informed decision depending on your project needs.

The Ecosystem section covers everything related to the world of Headless CMS and Strapi's place in it. 

Ecosystem

Comparing Headless CMS to Back-end Frameworks: Which One is Right for Your Project?

medium_Comparing Headless CMS to Back-end Frameworks_ Which One is Right for Your Project_.png

small_Comparing Headless CMS to Back-end Frameworks_ Which One is Right for Your Project_.png

thumbnail_Comparing Headless CMS to Back-end Frameworks_ Which One is Right for Your Project_.png

Comparing Headless CMS to Back-end Frameworks_ Which One is Right for Your Project_.png

Waterloo

User Success

Learn how to set the default "populate" options via route middleware. Instead of passing "populate" on each request from the frontend, the can handle this functionality via route-based middleware in the backend. This will allow you to keep your frontend requests lean and organized.
 
You can also use this to control what data will be returned by default and not allow the user to add additional populate options in the frontend.
 
## What is Route Middleware?
In Strapi, Route Middleware has a more limited scope and is configured and used as middleware at the route level. You can [learn more in the Strapi documentation](https://docs.strapi.io/developer-docs/latest/development/backend-customization/routes.html#policies). Now, let's jump in and learn how to set this up.
 
## Sample Content Structure
In this example, I will use a simple blog post type consisting of a title, body, hero image, slug, and authors, which is a one-to-many relationship with a user. Each blog post can have many authors.
 
![sample content structure](https://camo.githubusercontent.com/f138cc8dc200ad473877f082d3ad8c445f1d48f08c88541e301c41b992353cd5/68747470733a2f2f7265732e636c6f7564696e6172792e636f6d2f64786768747170616f2f696d6167652f75706c6f61642f76313636303037313036352f53637265656e5f53686f745f323032322d30382d30395f61745f322e35302e30385f504d5f7576726f6a672e706e67)
 
Before getting into how to implement custom middleware, let's look at why you might want to add middleware for this use case in the first place.
 
## The Problem
By default, population structure needs to be defined and sent on each `client-side` request, else the request will return only top-level parent content.
 
A `GET` request to `localhost:1337/api/blog-posts` returns the following:
 
```
// localhost:1337/api/blog-posts
{
 "data": [
   {
     "id": 1,
     "attributes": {
       "title": "Test Blog Post",
       "body": "Test blog content",
       "slug": "test-blog-post",
       "createdAt": "2022-08-09T18:45:19.012Z",
       "updatedAt": "2022-08-09T18:45:21.710Z",
       "publishedAt": "2022-08-09T18:45:21.707Z"
     }
   }
 ],
 "meta": {
   "pagination": {
     "page": 1,
     "pageSize": 25,
     "pageCount": 1,
     "total": 1
   }
 }
}
```
 
This is not ideal, seeing as important data has been excluded, such as the `heroImage` and `authors`' information.
 
## Populate = *
An easy solution to the problem above involves adding `populate=*` to the initial query.
 
`localhost:1337/api/blog-posts?populate=*` returns the following:
 
```js
// localhost:1337/api/blog-posts?populate=*
{
 "data": [
   {
     "id": 1,
     "attributes": {
       "title": "Test Blog Post",
       "body": "Test blog content",
       "slug": "test-blog-post",
       "createdAt": "2022-08-09T18:45:19.012Z",
       "updatedAt": "2022-08-09T19:22:39.637Z",
       "publishedAt": "2022-08-09T18:45:21.707Z",
       "heroImage": {
         "data": {
           "id": 1,
           "attributes": {
             "name": "test_cat.jpeg",
             "alternativeText": "test_cat.jpeg",
             "caption": "test_cat.jpeg",
             "width": 500,
             "height": 500,
             "formats": {
               "thumbnail": {
                 "name": "thumbnail_test_cat.jpeg",
                 "hash": "thumbnail_test_cat_2bdaa9fbe9",
                 "ext": ".jpeg",
                 "mime": "image/jpeg",
                 "path": null,
                 "width": 156,
                 "height": 156,
                 "size": 5.01,
                 "url": "/uploads/thumbnail_test_cat_2bdaa9fbe9.jpeg"
               }
             },
             "hash": "test_cat_2bdaa9fbe9",
             "ext": ".jpeg",
             "mime": "image/jpeg",
             "size": 21.78,
             "url": "/uploads/test_cat_2bdaa9fbe9.jpeg",
             "previewUrl": null,
             "provider": "local",
             "provider_metadata": null,
             "createdAt": "2022-08-09T19:06:25.220Z",
             "updatedAt": "2022-08-09T19:06:25.220Z"
           }
         }
       },
       "authors": {
         "data": {
           "id": 1,
           "attributes": {
             "username": "testUser",
             "email": "test@test.com",
             "provider": "local",
             "confirmed": true,
             "blocked": false,
             "createdAt": "2022-08-09T19:07:03.325Z",
             "updatedAt": "2022-08-09T19:07:03.325Z"
           }
         }
       }
     }
   }
 ],
 "meta": {
   "pagination": {
     "page": 1,
     "pageSize": 25,
     "pageCount": 1,
     "total": 1
   }
 }
}
```
 
While this does return *more* data, the main flaw with this approach is that you don't have control over *what* data is returned. You are still not receiving valuable information, such as the author's `role` while also receiving data you might not care about.
 
## Getting Granular
Instead of using `populate=*`, you can filter the query using [LHS Bracket syntax](https://docs.strapi.io/developer-docs/latest/developer-resources/database-apis-reference/rest/api-parameters.html).
 
The query might look like this:
 
```
localhost:1337/api/blog-posts?populate[heroImage][fields]
[0]=name&populate[heroImage][fields]
[1]=alternativeText&populate[heroImage][fields]
[2]=caption&populate[heroImage][fields]
[3]=url&populate[authors][fields]
[0]=username&populate[authors][populate][role][fields]
[0]=name
```
 
While this correctly returns the data specified, it is not feasible to use. This query is quite unruly and certainly not something you'd want to consistently use throughout your application.
 
## Enter... Query-String
Using [query-string](https://www.npmjs.com/package/qs), we can implement the same query as above in a much more readable and reusable manner. The query can easily be used directly in the front-end of our application.
 
For example:
 
```js
const qs = require('qs')
const query = qs.stringify(
 {
   populate: {
     heroImage: {
       fields: ['name', 'alternativeText', 'caption', 'url'],
     },
     authors: {
       fields: ['username'],
       populate: {
         role: {
           fields: ['name'],
         },
       },
     },
   },
 },
 {
   encodeValuesOnly: true, // prettify URL
 }
)
// `localhost:1337/api/blog-posts?${query}`
```
 
It successfully returns the same result as the above query where we used bracket syntax:
```
{
 "data": [
   {
     "id": 1,
     "attributes": {
       "title": "Test Blog Post",
       "body": "Test blog content",
       "slug": "test-blog-post",
       "createdAt": "2022-08-09T18:45:19.012Z",
       "updatedAt": "2022-08-09T19:22:39.637Z",
       "publishedAt": "2022-08-09T18:45:21.707Z",
       "heroImage": {
         "data": {
           "id": 1,
           "attributes": {
             "name": "test_cat.jpeg",
             "alternativeText": "test_cat.jpeg",
             "caption": "test_cat.jpeg",
             "url": "/uploads/test_cat_2bdaa9fbe9.jpeg"
           }
         }
       },
       "authors": {
         "data": {
           "id": 1,
           "attributes": {
             "username": "testUser"
           }
         }
       }
     }
   }
 ],
 "meta": {
   "pagination": {
     "page": 1,
     "pageSize": 25,
     "pageCount": 1,
     "total": 1
   }
 }
}
```
> For many use cases, this will be the logical end. However, if you find that you are re-using the same query over and over again, read on.
 
## Query Logic in Middleware
Now that you know how to build useful queries, you can look at optimizing the process further by adding a query directly into route-based middleware.
 
### Initializing the New Middleware
In Strapi, you can generate boilerplate code directly from the CLI. In your terminal, run the command:
 
```bash
yarn strapi generate
```
 
From there, navigate to `middleware`.
 
![middleware](https://camo.githubusercontent.com/4d1ae1ae5760e28d759d98e27acf580c39c0cc0213ec03f6c6332f4fe6bd2f44/68747470733a2f2f7265732e636c6f7564696e6172792e636f6d2f64786768747170616f2f696d6167652f75706c6f61642f76313636303136303835322f53637265656e5f53686f745f323032322d30382d31305f61745f332e34342e35335f504d5f61756879646f2e706e67)
 
You will be prompted to name the middleware. Then, you will need to select where you want to add this middleware.
 
![run middleware](https://camo.githubusercontent.com/d91c7ea8176390eab732316ae867bacc94f4802b97a9a1da18b6d2814f5a26d2/68747470733a2f2f7265732e636c6f7564696e6172792e636f6d2f64786768747170616f2f696d6167652f75706c6f61642f76313636303136313235332f53637265656e5f53686f745f323032322d30382d31305f61745f332e35342e30305f504d5f6467387964342e706e67)
 
For this example, choose `Add middleware to an existing API` since you only want it to run on the blog-post route.
 
![select route](https://camo.githubusercontent.com/d9b871b068543d4707eed05a8b5f3681a067aa0bfa9fbc6bbe9d4a2ccb52f8c9/68747470733a2f2f7265732e636c6f7564696e6172792e636f6d2f64786768747170616f2f696d6167652f75706c6f61642f76313636303136313336322f53637265656e5f53686f745f323032322d30382d31305f61745f332e35352e35325f504d5f69676e6263622e706e67)
 
Now in the Strapi project, if you navigate to `src > api > blog-post > middlewares > test.js`, you will see the following boilerplate:
 
```js
'use strict'
 
/**
* `test` middleware.
*/
 
module.exports = (config, { strapi }) => {
 // Add your own logic here.
 return async (ctx, next) => {
   strapi.log.info('In test middleware.')
 
   await next()
 }
}
```
### Enable Middleware on Route
Before utilizing the middleware, you first need to enable it on the route.
 
If you head to ```src > api > blog-post > routes > blog-post.js```, you'll see the default route configuration:
 
```js
'use strict'
 
/**
* blog-post router.
*/
 
const { createCoreRouter } = require('@strapi/strapi').factories
 
module.exports = createCoreRouter('api::blog-post.blog-post')
```
 
Edit this file as follows:
 
```js
'use strict'
 
/**
* blog-post router.
*/
 
const { createCoreRouter } = require('@strapi/strapi').factories
 
module.exports = createCoreRouter('api::blog-post.blog-post', {
 config: {
   find: {
     middlewares: ['api::blog-post.test'],
   },
 },
})
```
 
> **Pro Tip:** If you can't remember the internal UIDs of the middleware, which is `api::blog-post.test`, run the command below:
 
```bash
yarn strapi middlewares:list
```
 
This will give you a list of all internal middleware UIDs in your project
 
![list of middleware](https://camo.githubusercontent.com/9952de6b542361258829a4ef7b926b1241c5a471d03e6e237eb9270c3487f5d7/68747470733a2f2f7265732e636c6f7564696e6172792e636f6d2f64786768747170616f2f696d6167652f75706c6f61642f76313636303136333135302f53637265656e5f53686f745f323032322d30382d31305f61745f342e31372e32395f504d5f6c306d68726f2e706e67)
 
To see all of the available customizations for core routes, [check out the docs](https://docs.strapi.io/developer-docs/latest/development/backend-customization/routes.html#configuring-core-routers).
 
## Adding Logic to the Middleware
Now that thw middleware has been initialized in your project and added to the `blog-post` route, it's time to add some logic.
 
The purpose of this middleware is so you do not need to build your query on the frontend to return the data you are looking to fetch.
 
By adding your logic directly to the middleware, all of the querying will happen automatically when you head to the `localhost:1337/api/blog-post` route.
 
Instead of writing your query on the frontend, add it directly to the middleware, as such:
 
```js
// src > api > blog-post > middlewares > test.js
 
module.exports = (config, { strapi }) => {
 // This is where we add our middleware logic
 return async (ctx, next) => {
   ctx.query.populate = {
     heroImage: {
       fields: ['name', 'alternativeText', 'caption', 'url'],
     },
     authors: {
       fields: ['username'],
       populate: {
         role: {
           fields: ['name'],
         },
       },
     },
   }
 
   await next()
 }
}
```
 
Now, stop the Strapi server and run `yarn strapi build` to rebuild your Strapi instance. Once the build is complete, run `yarn develop` to restart the Strapi server.
 
If you go to the route `localhost:1337/api/blog-posts` the response returns:
 
```js
{
 "data": [
   {
     "id": 1,
     "attributes": {
       "title": "Test Blog Post",
       "body": "Test blog content",
       "slug": "test-blog-post",
       "createdAt": "2022-08-09T18:45:19.012Z",
       "updatedAt": "2022-08-09T19:22:39.637Z",
       "publishedAt": "2022-08-09T18:45:21.707Z",
       "heroImage": {
         "data": {
           "id": 1,
           "attributes": {
             "name": "test_cat.jpeg",
             "alternativeText": "test_cat.jpeg",
             "caption": "test_cat.jpeg",
             "url": "/uploads/test_cat_2bdaa9fbe9.jpeg"
           }
         }
       },
       "authors": {
         "data": {
           "id": 1,
           "attributes": {
             "username": "testUser"
           }
         }
       }
     }
   }
 ],
 "meta": {
   "pagination": {
     "page": 1,
     "pageSize": 25,
     "pageCount": 1,
     "total": 1
   }
 }
}
```
 
No query string is needed!
 
## Congrats on Making it to the End!
Here is a recap of what you've just learned:
- How to use `populate=*`.
- How to query and filter using [LHS Bracket syntax](https://docs.strapi.io/developer-docs/latest/developer-resources/database-apis-reference/rest/api-parameters.html).
- How to use [query-string](https://www.npmjs.com/package/qs) to build custom client-side queries for better re-use.
- How to add custom middlewares to your project.
- How to implement middlewares on an api route.



Learn how to set the default "populate" options via route middleware in the backend. 