Learn how to create a Pet Adoption CRUD application using Strapi headless CMS for the backend, and React with Redux for the frontend. 

How to Build a CRUD App with React and a Headless CMS

In this step by step tutorial, we will learn how to connect Strapi to PostgreSQL, add API endpoints manually on Strapi to create a Bank admin app

PostgreSQL and Strapi setup

In this article, we will look into the relational fields in Strapi to see how we can utilize them to establish relationships in our models.


Understanding and using Relations in Strapi

In this tutorial, you’ll learn how to build a messaging app with Strapi on the backend and Next.js on the frontend. 

Using Custom Controllers to Power a Next.js App

In this tutorial, you’ll learn the basics of SvelteKit and create a blog website using the SvelteKit framework and using Strapi for content management.


How to Create a Blog with SvelteKit and Strapi

Pagination is an optimization technique that is used to enhance the performance of your applications. In this tutorial, you will learn how to implement pagination in Strapi - both on the backend and the frontend.

Handling Pagination in Strapi v4 with SvelteKit

Blog

The Product section covers our releases, feature reviews and more. 

Product

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

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

Ecosystem

The latest Strapi-related news and major events happening for Strapi – including announcements, remote-work, organization and tips on running a start-up. 

Company

Get all the latest updates, news and events.

Subscribe to the newsletter 📣

Get all the latest Strapi updates, news and events.

Join our Newsletter

Simply copy and paste the following command line in your terminal to create your first Strapi project. 

Get Started

Learn how to set up a GraphQL endpoint in a Strapi backend along with Flutter, a powerful open-source UI development kit for Android, iOS, Linux, Mac, Windows, Google Fuchsia, and the web to build a To do app

Frame 84-5.png

Build a To-Do App with Strapi GraphQL Plugin and Flutter

Frame 84-3.png

Editor's Picks

From the origin of the web to modern content infrastructure, learn what is headless CMSs, their benefits, and the way to use them.

The Ultimate Guide to Headless CMS

thumbnail_guide to headless cms.png

guide to headless cms.png

Announcing today a $4M Seed funding led by Accel and Stride.vc, and angel investors and open-source experts Solomon Hykes, Guillermo Rauch and Eli Collins.

Announcing Strapi’s $4M Seed Funding Round with Accel and Stride.vc

announcing-strapi-4m-seed-funding-round

Announcing today a $10M Series A funding led by Index Ventures with the participation from notable angel investors and open-source experts, including Augusto Marietti and Marco Palladino, CEO and CTO of Kong, respectively, and David Cramer, co-founder and CTO of Sentry.

strapicover

Strapi closes $10 M series A Funding

In this article, we take a look at the Top Blog Posts published on the Strapi Blog in 2020.

top_blog_post_2020.png

Top 10 Blog Posts of 2020

Today we are thrilled to announce our $4M Seed funding led by **Accel** and [**Stride.vc**](http://stride.vc/). Notable angel investors and open-source experts, **Solomon Hykes** (Founder of Docker), **Guillermo Rauch** (Founder of Cloudup, [Socket.io](http://socket.io/), Next.js and [Zeit.co](http://zeit.co/)) and **Eli Collins** (Ex-CTO at Cloudera), also participated in this round.

![](https://lh5.googleusercontent.com/D5_jr0mBMb4ZGEUc0l3GtrfTfcE4cAluPiCfXTuoaI9H0d9LA_7goV12K5s0QjO8DiguQeCVVt1wSKhA3gXSDDvrTFpL1W4RRghjsliKT816WwYuQ18UNGxonb29P05A4GW6__7E)

This funding boost will help deliver on our vision of **making content accessible to any platform** while offering the only **fully open-source**, **JavaScript-based**, **community-powered** and **100% customizable Headless CMS** which is **entirely free for developers.**

Before announcing what we have in the pipeline, let's start with a little bit of history!

## **The story of Strapi**

#### Who we are

When we met at University in 2013, [Aurélien](https://twitter.com/aureliengeorget), [Jim](https://twitter.com/laurie_jim) and me, [Pierre](https://twitter.com/pierre_burgy), were already passionate about the Internet and web development.

Like many programmers, we started building websites using traditional CMSs such as WordPress, Joomla, and Drupal. They saved us an incredible amount of time.

#### More and more devices

After the emergence of the smartphone and the explosion in form factors and devices, the content game changed. It wasn't just a question of responsive design, but of being able to present and consume content and data in a myriad of environments from sites, to apps, to smartwatches, etc. Instead of duplicating content management, it started to make sense to centralize and make it omnichannel.

#### JavaScript applications

At the same time, even website creation had also changed. We started seeing super-fast and AJAX-based sites, providing smooth user experiences. The word "web app" became a thing.

As a cause and consequence, the first front-end frameworks appeared. Angular 1 (do you remember the good old ng-repeat?) was one that broke all the rules. Developers became more and more full-stack and started dividing their projects into separate directories (e.g., API and client).

*Front-End and Back-End divorced. The API was the only bridge between them.*

The only concern was the SEO limitations (HTML pages were almost empty). This issue was quickly solved thanks to pre-rendering solutions and, later on, static website generators and server-side rendering. After that, nothing could stop the movement! The success of React and Vue.js provides the best evidence of that.

#### Tweaking traditional CMS into APIs

Traditional CMSs were built 15 years ago and were fine when we had to make a website. For that reason, their name should probably be "website builders" or "website managers." But when we needed to build mobile applications, they were not the right tool. The only way to "APIfy" traditional CMSs was to hack them, and the result was always dirty, slow, and not customizable...

#### Strapi was born!

At that time, Node.js was already growing like crazy. Being PHP, Java, and JavaScript developers, we saw in JavaScript the opportunity to use only one language for both the front-end and the back-end. Since we were heavy users of open-source projects and because we already thought that a Headless CMS should be open-source, we published the project on GitHub in October 2015.

*Frustrated by the limitations of traditional CMSs, we finally said: “Let’s create our own!”*

First users, first GitHub stars, first pull-requests. What an amazing feeling!

#### From side project to an open-source company

In 2016 we incorporated the company and developed a few projects with the software to battle test it. We learned so much from these use-cases that we decided to restart the project from scratch and publish the new version in October 2017.

Since then, the project has grown like crazy. Used by thousands of companies like IBM, Asos, and Walmart, Strapi finally became **the #1 Open-Source Headless CMS**.

## **What's next**

What does this fundraising mean for you? Only good news, that's why we are so excited!

#### Providing the Headless CMS of your dream

Our primary focus is to **provide the most [requested features](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration)** and enhance existing ones. Strapi will not only be easier to use but will also become even **easier to deploy**. Not only that, we will release the **stable version**.

For more information, please take a look at the [public roadmap](https://portal.productboard.com/strapi) and upvote your most needed improvements.

#### Offering a seamless Developer Experience

For technical products, the **documentation** is always a critical part of the user experience. To render it more efficient, we will update the structure and add more guides to explain advanced usage, including **customization** and **plugin development**.

Through the brand new [tutorial section of the website](https://strapi.io/tutorials), everyone can now enjoy a growing number of **tutorials** and publish new ones.

#### Building a robust ecosystem

Strapi has been designed to be highly **customizable** and **extensible** through a powerful **plugin system**. This system will be finalized to make plugin development, publication, and updates seamless. That way, absolutely anyone can contribute and make the ecosystem bigger than we can imagine today!.

The aim of a Headless CMS is to be connected to clients, via a website, a mobile application, or even a fridge! We plan to offer a smooth experience while providing **SDKs**, **integrations**, and **starters**.

#### Growing the community

If you submitted a pull-request, tweeted about Strapi, or even if you recommended Strapi to one of your colleagues, you have already become part of the community.

As such, you participate by helping other users, improving the project, or passing the word around you to grow the ecosystem. We will provide more resources so you can easily organize events in your city, write tutorials, etc.

#### Business model

As an open-source company, we will have to make money at some point. In the future, we will start offering **paid features for enterprise use-cases**. We want to keep developer-oriented functionalities free while charging a small fee for business-oriented advanced features.

>Whatever happens open-source will always stay open-source.

Our investors and advisors are firm believers in the open-source approach. Like you and us, they totally understand and approve the approach.

## **Thank you for believing in us!**

All this would not have been possible without the help of the 250 people who have contributed to the project and the thousands of users who give us feedbacks every day, spreading the word and encouraging us. Thank you again to each of you for your fantastic contribution!

Thanks to our team for working so hard every single day and creating the great atmosphere we share!

And of course, we are also grateful to our investors who strongly believe in our vision.

---

So we have a lot on our plate! To be able to reach all these goals, today, we are seeking the best talents. If you share our values (Excellence, Care, Passion, Humility, Transparency, and Positivity) and want to be part of this journey, take a look at the [open positions](https://www.welcometothejungle.co/en/companies/strapi/jobs) and join us!

## Introduction

We’re very excited to [announce that Strapi, Inc has raised $10 million in Series A funding](https://www.businesswire.com/news/home/20200520005179/en/Strapi-Maker-Popular-Open-Source-Software-Creating). The round was led by [Index Ventures](https://www.indexventures.com/) with the participation from notable angel investors and open-source experts, including Augusto Marietti and Marco Palladino, CEO and CTO of Kong, respectively, and David Cramer, co-founder and CTO of Sentry.

Only 6 months after raising $4 million in [seed funding](https://techcrunch.com/2019/10/15/headless-cms-company-strapi-raises-4-million/) with Accel and Stride.VC, this new round has brought the company’s total funding to $14 million.

Strapi is now in a unique position to realize and execute its mission of fueling the world’s creativity and productivity by unleashing the power of content. With the help of amazing open source contributors, we’re creating the most customizable CMS on the market and empowering developers to create millions of digital projects.

Now more than ever, our ability to successfully raise such a significant amount of funding is a real sign that Strapi is well-positioned to become an industry standard as the **de facto Headless CMS**. Such an achievement has only been possible through the wonderful support of the broader [Strapi community](https://strapi.io/community) and the core Strapi team. The continual contributions to Strapi are what make it what it is today.

We also are very excited to share with you today our [new website](https://strapi.io) and branding! We will soon publish a post to give you more details about the process we went through and the stack we use, which obviously includes Strapi.

We would like to send out a special thank you to everyone who has taken the time to become a part of the journey!

When [websites are regularly crashing](https://www.fastcompany.com/90478927/unemployment-websites-from-oregon-to-ny-are-crashing-under-the-weight-of-the-coronavirus-crisis) under the strain of an ever-increasing volume of traffic, the Strapi's value for making the web faster and more secure at a lower cost makes more sense than ever.

## Welcoming Index to the Strapi family 

Some of the most successful projects ever created, like Confluent, Elastic, Kong, or CockroachDB, have something significant in common: they are backed by [Index Ventures](https://www.indexventures.com/). 

Welcoming Index to the Strapi family makes perfect sense for us and puts our name among other game-changing projects. We are convinced that [their philosophy](https://www.indexventures.com/philosophy/), their experience with open-source projects, and their understanding of our vision will add a lot of value and strong benefits to Strapi and its community.

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

“The proliferation of different types of content being consumed on a growing number of devices has created a lot of complexity. Because of this, developers are taking the lead in building modern, custom solutions to make all content available anytime, anywhere,” said Ari Helgason, Principal at Index Ventures, who joined as a board member. “We’ve been impressed by Strapi’s API-based open-source approach that puts developers in charge, and are excited to partner with the Strapi team in building the CMS that will be powering the internet.”

## JAMstack and the Strapi Ecosystem

The CMS market has drastically changed in the last decade. Over the past few years especially, content has evolved and is no longer only displayed on websites in a browser. Everything is published on a countless number of devices and mediums. Even the basics of website creation have changed with front-end developers wanting to use modern frameworks like React, Next.js, Gatsby, Vue.js, Nuxt.js, or Angular in order to ensure quick and responsive experiences for end-users.

All these changes in use-cases and expectations have led to a new architecture: the **JAMstack**. Front-end deployment is now completely separated from the CMS. Content is now served via an API.

While traditional CMSs are decreasing in popularity, headless ones are gaining market share. Having an API-first CMS designed for modern, omnichannel, digital experiences, offers unlimited possibilities for content.

![Screen Shot 2020-05-19 at 22.16.35](https://api-prod.strapi.io/uploads/Screen_Shot_2020-05-19_at_22.16.35_5ee31a544c.png)

Strapi, Headless CMS, and JAMstack in Google Trends

Strapi has been committed to being fully **open-source** under a permissive MIT license since day one. The other founders and I have all experienced building websites with a traditional CMS, making it an easy choice to build something that is open-source and welcoming to a community of contributors. 

We wanted the leading Headless CMS to be made and supported by a worldwide community of developers and fans. 

The CMS market has always been led by open-source software and big companies have always wanted to host content in-house, on their servers. The ongoing issues have always stemmed from how developers, content creators, and end-users need flexibility and customization.

5 years after the first commit to Strapi on GitHub and we're all the more confident in our decision. The numbers speak for themselves:

- 1 million downloads on npm
- 25,000+ stars on GitHub
- 400+ contributors – 95 percent outside of the core Strapi team
- 13,000+ commits
- 300+ Community plugins published on npm
- 10+ community-led user-groups
- 4,000+ Strapi related projects on GitHub
- Integration with many technology providers, deployment, and cloud platforms

In 2020, Strapi powers thousands of projects. From small businesses to Fortune 500 companies, Strapi covers industries as diverse as [IBM](https://www.research.ibm.com/artificial-intelligence/), [NASA](https://esc.gsfc.nasa.gov/), [Société Générale](https://strapi.io/user-stories/societe-generale-e-training-platform) and [Delivery Hero](https://strapi.io/user-stories/delivery-hero).

## How We Will Use the New Funding

#### Investing in the Open Source Community

As a part of the open-source movement, Strapi will always have one top priority: growing the community and ensuring everyone enjoys contributing to Strapi.

The new boost in funding is sure to help us release new features in accordance with those most requested on our [public roadmap](https://portal.productboard.com/strapi/1-public-roadmap/).

The goal is to build a better product that works with the community. As a part of that, the bigger core Strapi team will allow for even better [documentation](https://strapi.io/documentation/3.0.0-beta.x/getting-started/quick-start.html), guides, and community support.

The Strapi community is global. Connecting developers and creators all over the world lets more and more people work together while gaining new insights and perspectives into how to build the best CMS in the world.

In order to further facilitate these unique opportunities, we will double our effort to publish more [tutorials](https://strapi.io/tutorials) with the [Write For The Community program](https://strapi.io/blog/write-for-the-community) and organize more [meetups](https://strapi.io/blog/bringing-community-together-strapi-meetups) no matter where you are. Even if everything needs to be completely virtual for a while, we are committed to helping build a community that enjoys exchanging thoughts and sharing ideas.

#### Building a Marketplace for the Strapi Ecosystem

The success behind the vast majority of open-source projects has always depended on the community and the ecosystem supporting the project.

Strapi has always been designed around an eventual extensive plugin system. After creating [Buffet.js](https://buffetjs.io/), the React component library used in Strapi, we knew we wanted to give anyone and everyone the ability to create plugins using the same design.

While the beginnings of the plugin system are already available, we will be drastically improving the entire experience. Developing, installing, and updating a plugin will be easier than ever, thanks to internal APIs.

300 community plugins published on npm is a very good start. Some of them are listed on the [awesome-strapi repository](https://github.com/strapi/awesome-strapi). We're aiming to make the list grow into thousands of plugins. Help us work together to make the number of features, integrations, and use-cases nearly infinite!
 
#### Building Enterprise Capabilities

The open-source version of Strapi is and will stay free and open-source. However, as a company we also have to generate profit in order to become a sustainable business, allowing us to further invest in and support the open-source Strapi project.

We will keep continually releasing more and more free and open-source features, but on top of that will develop paid features (delivered as plugins) for product and marketing teams managing content at scale. 

Similar to [Elastic](https://www.elastic.co/blog/doubling-down-on-open) and [GitLab](https://gitlab.com/gitlab-org/gitlab/-/tree/master/ee), Strapi is built on an open-core model. That means there are two versions of Strapi: Community Edition (CE) and Enterprise Edition (EE). 

Like the Community Edition, both the roadmap and source code of the enterprise version will be openly planned and developed. Anyone interested, whether they be partners or customers, can easily contribute to the code.

Some of the features included in our Enterprise Edition roadmap include advanced [Role-Based Access Control](https://portal.productboard.com/strapi/1-public-roadmap/c/8-users-roles-permissions-ce-ee), [Content Internationalization](https://portal.productboard.com/strapi/1-public-roadmap/c/19-content-internationalization-ce-ee), SSO, Audit Logs and advanced publication workflows. The first version of Strapi EE with Role-Based Access Control will be available beginning of July. 

Feel free to fill out [this form](https://strapi.io/enterprise) for more information.

## Onward and Upward 

This fundraising round is great news for Strapi and the community, but the best is yet to come!
Thank you again to all the contributors and our dedicated team for making Strapi better every day.
As a part of our efforts to better the entire Strapi experience, we opened several job positions. If you want to be part of the next step in the journey, feel free to [apply here](https://www.welcometothejungle.com/en/companies/strapi/jobs)!

Want to try out Strapi? Take a look at the [getting started guide](https://strapi.io/documentation/3.0.0-beta.x/getting-started/quick-start.html) or test everything out with a [live demo](https://strapi.io/demo).
It goes without saying, but everyone at Strapi also wishes you the best in these troubling times. Stay safe and let's work on building a better future for content together!

If you want to learn more about Strapi and our roadmap, sign up for a live Q&A with Strapi co-founders: Pierre Burgy (CEO), Aurélien Georget (CPO) and Jim Laurie (CTO) next **Thursday, May 28th at 9 am PST**.

<iframe width="100%" height="360" frameborder="0" src="https://app.livestorm.co/p/4546d94c-9f44-4be1-af89-c41eeb2e4bdf/form"></iframe>


> Our community is looking for talented writers who are passionate about our ecosystem (jamstack, open-source, javascript) and willing to share their knowledge/experiences through our [Write for the community program](/write-for-the-community).

The year is coming to an end and looking back, we can't help but think about what a year it's been! We have published over 115 blog posts, with over 30 of these being direct contributions from Community members under the [Write for the Community Program](https://strapi.io/write-for-the-community), it's been a tough year and for many, the posts from our blog have, even in the most minute way possible, made their lives easy. Confinement and lockdown meant a lot of people did a lot of reading. In this article, we're going to take a look at the 10 most popular blog posts published on the Strapi Blog in 2020. You might just uncover some gems lost in time 😉

#### [Strapi Starter React blog](https://strapi.io/blog/strapi-starter-react-blog)
Learn about Strapi Starters and get started with using our official React Starter.

#### [Build a blog using Strapi, React and Apollo](https://strapi.io/blog/build-a-blog-with-react-strapi-and-apollo)
Get an in-depth tutorial on how to build a blog website with React, Strapi and Apollo GraphQL.

### [What are Webhooks and how to use them in Strapi](https://strapi.io/blog/webhooks)
Find out what webhooks are and learn how to use them in Strapi.

### [Build a blog using Strapi, Nuxt (Vue) and Apollo](https://strapi.io/blog/build-a-blog-using-nuxt-strapi-and-apollo)
Get an in-depth tutorial on how to build a blog website with Nuxt, Strapi and Apollo GraphQL.

### [🍝 Cooking a Deliveroo clone with Next.js (React), GraphQL, Strapi and Stripe - 🏗️ Setup (part 1/7)](https://strapi.io/blog/strapi-next-setup)
Learn to develop a Deliveroo clone using [Next.js](https://nextjs.org) ([React](https://reactjs.org)),[  GraphQL](https://graphql.org),[  Stripe](http://stripe.com/) and[  Strapi](https://strapi.io/)

### [Build a blog using Strapi, Angular and Apollo](https://strapi.io/blog/build-a-blog-with-angular-js-strapi-and-apollo)
Learn to create a blog website using Strapi as the backend, Angular for the frontend, and Apollo for requesting the Strapi API with GraphQL.

### [Build a static blog using Gatsby and Strapi](https://strapi.io/blog/build-a-static-blog-with-gatsby-and-strapi)
Get an in-depth tutorial on how to build a static blog website with Gatsby and Strapi.

### 🍝 [Cooking a Deliveroo clone with Nuxt.js (React), GraphQL, Strapi and Stripe - 🏗️ Setup (part 1/7)](https://strapi.io/blog/cooking-a-deliveroo-clone-with-nuxt-vue-js-graphql-strapi-and-stripe-setup-part-1-7)
Learn to develop a Deliveroo clone using [Nuxt](https://nuxtjs.org) ([Vuejs](https://vuejs.org)),[  GraphQL](https://graphql.org),[  Stripe](http://stripe.com/) and[  Strapi](https://strapi.io/)

### [How to run a Strapi dev stack with Docker compose](https://strapi.io/blog/how-to-run-a-strapi-dev-stack-with-docker-compose)
Get started with using Strapi with Docker for your developer environment.

### [Build a blog using Strapi, Vue and Apollo](https://strapi.io/blog/build-a-blog-with-vue-strapi-and-apollo)
Learn to create a blog website using Strapi as the backend, Vue for the frontend, and Apollo for requesting the Strapi API with GraphQL.

### [Build a blog using Strapi and Next.js](https://strapi.io/blog/build-a-blog-with-next-react-js-strapi-and-apollo)
Get an in-depth tutorial on how to build a blog website with Next, Strapi and Apollo GraphQL.


We can't ignore the fact that time played a significant role in making these posts as widely read as they were. Given that understanding, we've got a few posts that we think need a little more attention from everyone 😉

### [Build a static blog using Gatsby (Typescript) and Strapi](https://strapi.io/blog/build-a-static-blog-with-gatsby-typescript-and-strapi)
Learn to create a simple static blog website using Strapi as the backend and Gatsby for the frontend, using TypeScript.

### [Creating a Strapi Dynamic Zone & Rendering it in your Nuxt.js App](https://strapi.io/blog/creating-strapi-dynamic-zone-in-nuxtjs-app)
Get started with building a company website using Nuxt.js that utilizes Strapi Dynamic Zones.

### [Strapi Authentication in Nuxt.js](https://strapi.io/blog/strapi-authentication-in-nuxt-js)
Dive into this step-by-step guide on how to implement Strapi-based authentication in a Nuxt.js app.

### [Announcing Strapi 3.1 - Administrator Roles & Permissions](https://strapi.io/blog/announcing-3.1-role-based-access-control)
Learn how to use one of Strapi's most requested features - Role-based Access Control.

### [Adding Idyll Support to Strapi](https://strapi.io/blog/adding-idyll-support-to-strapi)
Follow this guide on how to customize the admin panel in order to add Idyll support to the default markdown rich text editor.

### [Integrate Strapi With Everything](https://strapi.io/blog/integrate-strapi-with-everything)
Learn how to use Strapi on (almost) any frontend system.

### [Building a Jamstack Food Ordering App with Strapi, Gridsome & Snipcart](https://strapi.io/blog/building-a-jamstack-food-ordering-app-with-strapi-gridsome-and-snipcart-1-6)
Go through the processes of setting up your own food ordering application and by extension any e-commerce app using modern development tools like[  Strapi](https://strapi.io/),[  Gridsome](https://gridsome.org/) and[  Snipcart](https://snipcart.com/).

### [Adding Cloudinary support to your Strapi Application](https://strapi.io/blog/adding-cloudinary-support-to-your-strapi-application)
Get up to speed with how to change the default upload provider of your Strapi application to Cloudinary.

Hopefully, this helps you do some holiday reading or serves as a just distraction or helps you learn something new. We appreciate you finding the time to engage with the content we put out and look forward to more of the same and better next year. Have a great one ❤

Strapi and Gatsby are a great match! Strapi can handle all your content workflows, and Gatsby makes that content shine by building blazing fast websites.
The Gatsby Source Strapi plugin now supports internationalization, dynamic zones, Gatsby v3, and more! 

Gatsby plugin blogpost cover (1).png

Introducing the new Gatsby Source Strapi plugin

A quick review on MongoDB support and the latest announcement regarding  next steps.

Strapi Guided Tour-7.png

MongoDB support in Strapi: Past, Present and Future

Starters are pre-made frontend applications linked to a template with configured content types or plugins that make it easier for you to get started with Strapi

Strapi Custom Plugin-18.jpg

Everything you need to know about Strapi Starters

>*The updated version of this plugin supporting Strapi v4 and Gatsby Cloud has been released. Check it out [here](https://strapi.io/blog/gatsby-source-strapi-supporting-v4-and-gatsby-cloud).*

We know that many of you love using Strapi with Gatsby. It's a great match! Strapi can handle all your content workflows, and [Gatsby](https://strapi.io/integrations/gatsby-cms) makes that content shine by building super fast (dare I say *blazing*?) websites.

That's why we created the [gatsby-source-strapi](https://github.com/strapi/gatsby-source-strapi) plugin. It helps you query Strapi content in Gatsby, and lets you benefit from all the Gatsby goodness, like their automatic [image optimization](https://www.gatsbyjs.com/docs/reference/built-in-components/gatsby-plugin-image/).

But our plugin was built in 2018, which, in the Jamstack world, is ages ago. So after [250.000](https://npm-stat.com/charts.html?package=gatsby-source-strapi) downloads, [65](https://github.com/strapi/gatsby-source-strapi/issues?q=is%3Aissue+is%3Aclosed) closed issues, and [55](https://github.com/strapi/gatsby-source-strapi/pulls?q=is%3Apr+is%3Aclosed) code contributions, it was time for a change. That's why we're happy to release our work in a new major version.

## What's new?

Both Strapi and Gatsby move fast and have recently released new versions and features. We have updated the plugin to let you benefit from the best and latest features of both products. This new release includes:

- **Internationalization support**

Strapi supports [Internationalization](https://strapi.io/features/internationalization) since v3.6. Before this release, our Gatsby source plugin only fetched content in the default locale. Now you can specify which locales you want to fetch for every content type. You can finally build websites that are translated for all your audiences!

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

- **Fixed dynamic zones support**

Dynamic zones had become a common pain point when using Gatsby with Strapi. We have now changed their behavior to rely on the JSON type. No need to write complex GraphQL fragments anymore :)

- **Support for Gatsby v3**

The internal code of the plugin has been updated to work with Gatsby's latest major version. You can safely upgrade your Gatsby version and enjoy the [speed boost](https://www.gatsbyjs.com/blog/gatsby-v3/).

- **Support for arrays of images**

Gatsby will now parse image fields, even if they come from an array of media fields, like a carousel. This means you can use the gatsby-plugin-image in even more places, and build more performant image-heavy pages.

- **New README documentation**

The source plugin's documentation was rewritten. It now features more examples for advanced configurations, like [custom endpoints](https://github.com/strapi/gatsby-source-strapi#custom-endpoint) or [authenticated requests](https://github.com/strapi/gatsby-source-strapi#authenticated-requests).

## Update your app to the new version

As this is a major release, there are a few breaking changes you need to make to enjoy the new version.

### 1. Update your Gatsby and Strapi versions

We recommend that you start by upgrading your frontend to Gatsby v3. If you're coming from the v2 version, you can follow [Gatsby's official migration guide](https://www.gatsbyjs.com/docs/reference/release-notes/migrating-from-v2-to-v3).

Then, make sure that your Strapi application is up to date as well. You want to have at least version 3.6, where we introduced [internationalization](https://strapi.io/blog/announcing-content-internationalization-v3-6). If your Strapi version is older,  follow [our docs on how to update Strapi](https://strapi.io/documentation/developer-docs/latest/update-migration-guides/update-version.html#update-strapi-version).

### 2. Update the source plugin

Now that we're done with Gatsby and Strapi versions, it's time to update the actual source plugin. Inside your Gatsby frontend, open a terminal and run either of these commands:
#### Using Yarn
```
yarn add gatsby-source-strapi@latest
```
#### Using NPM
```
npm install gatsby-source-strapi@latest 
```

You should now see the 1.0.0 version in your `package.json`.

### 3. Rename `contentTypes` to `collectionTypes`

Strapi offers two content types: collection types and single types. To avoid any confusion, we renamed the `contentTypes` option to `collectionTypes`, since it doesn't handle single types. So you will need to make a small change in your `gatsby-config.js` file:

```
// In your gatsby-config.js
plugins: [
  {
    resolve: `gatsby-source-strapi`,
    options: {
      apiURL: `http://localhost:1337`,
      // Instead of contentTypes: [`article`]
      collectionTypes: [`article`],
      singleTypes: [`home-page`, `contact`],
    },
  },
];
```
### 4. Rewrite your dynamic zones queries

If you have tried using dynamic zones with Gatsby before, you may have written GraphQL queries that involved complex fragments. Instead, you can rewrite them to only query the dynamic zone field as a scalar:

```
{
  allStrapiPage {
    edges {
      node {
        id
        # contentSections is a Strapi dynamic zone
        # All its contents will be queried as JSON
        contentSections
      }
    }
  }
}
```
## Get started with Strapi & Gatsby

We love working with Gatsby and are happy to make it easier to use for you. If you want an even faster way to get started with Strapi and Gatsby, you can check out our starters:

- [Gatsby blog](https://strapi.io/starters/strapi-starter-gatsby-blog)
- [Gatsby catalog website](https://strapi.io/starters/strapi-starter-gatsby-catalog)
- [Gatsby corporate website](https://strapi.io/starters/strapi-starter-gatsby-corporate)

We'll be updating these to use our new source plugin very shortly. Make sure you [follow us on Twitter](https://twitter.com/strapijs) so you can find out when this happens.

In the meantime, enjoy the new plugin, and don't hesitate to give us your feedback on [GitHub](https://github.com/strapi/gatsby-source-strapi)!


> Here's the [migration guide](https://docs.strapi.io/developer-docs/latest/update-migration-guides/migration-guides/v4/data/mongo.html) from MongoDB to SQL

Since 2017 and Strapi Alpha, we have always supported SQL databases such as MySQL, PostgreSQL, SQLite, MariaDB, and the document database MongoDB.

On April 29th, I posted a message on the Strapi forum announcing that we were thinking about officially [dropping our support for MongoDB in Strapi](https://forum.strapi.io/t/dropping-mongodb-support/4549). In an attempt to be fully transparent with the Strapi community, we provided some context about the problem and motivation for this important decision. In short, having to support two different connectors (SQL + MongoDB) is slowing down our product developments, and MongoDB usage represents less than 0.4% of all the Strapi projects (data is anonymously collected via [Telemetry system](https://strapi.io/documentation/developer-docs/latest/getting-started/usage-information.html)).

A lot has happened since then. We have heard your feedback and have been discussing with MongoDB, Inc to find a better solution. In case you have missed the latest update on the forum thread, below is a summary of the next steps we're taking to ensure the satisfaction of Strapi users who use MongoDB as their database:

-   We're partnering with MongoDB, Inc to sponsor [Valeri Karpov](https://twitter.com/code_barbarian?lang=en) ([Mongoose](https://github.com/Automattic/mongoose) maintainer) who will maintain the strapi-connector-mongoose package for the v3.

-   In Q4 2021, our plan is to start working with MongoDB engineers to develop a strong and better database connector system within Strapi. Although there is no known estimated release date at this point, we would like to work with Valeri to develop a MongoDB connector compatible with v4 and beyond.

-   For the beta and stable release of the [Strapi v4](https://forum.strapi.io/t/new-version-questions-thoughts-v4/4824), Strapi won't support MongoDB natively, and no connector will be available (yet).

We feel that this is really good news for the ecosystem. It's a compromise to ensure MongoDB will continue to be supported in Strapi v3 for at least 6 months after v4 stable is released, while removing the burden of  developing a database connector system in the v4. 

Even though MongoDB won't be supported right away in the v4, we look forward to working together with MongoDB Inc on the co-development of a new and more performant MongoDB connector starting in Q1 2022. Should the new MongoDB connector not be available on time by the end of life of Strapi v3, we'll provide tooling to ensure you can easily migrate projects using MongoDB v3 to Strapi SQL projects on v4.

Note: if you are currently using MongoDB in production and are a Strapi customer, feel free to reach out to our [Support team](https://support.strapi.io/) if you have any questions.

Get involved:
-   [Migrate your project from MongoDB to SQL](https://docs.strapi.io/developer-docs/latest/update-migration-guides/migration-guides/v4/data/mongo.html)

-   Learn more about the upcoming [Strapi v4](https://strapi.io/v4)

-   Join the [Strapi Community on Discord](https://discord.strapi.io/)

-   Collaborate with other users on the [Strapi Forum](https://forum.strapi.io/) 

-   Learn Strapi by reading our [blog](https://strapi.io/blog) and [tutorials](https://strapi.io/tutorials).

For quite some time, Strapi has been releasing tools to make it easier to get started with building with Strapi. Starters and templates have been a big part of bridging that usability gap. This article looks at Strapi Starters, what they are, and how they are making building with Strapi and on top of Strapi easier.

### What are Strapi Starters

The idea of[ Strapi Starters](https://strapi.io/starters) came from two observations. First off, Strapi users, for the most part, build for similar use cases, i.e., blogs, corporate websites, eCommerce apps, job boards, etc. Secondly, even though content modeling is a big part of Strapi, few people want to dive into doing it with nothing to start from for every project that they create. 

This is where Strapi Starters come in. They are pre-made frontend applications linked to a template with configured content types, components, dynamic zones, or plugins. The goal was to make it easier for anyone to get started with Strapi, and starters aim to do just that. If video content works better for you, we've got you covered too :)


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

### How do Strapi Starters work

Going a step higher from what Strapi Starters are, it's also essential to understand how they work. Strapi [templates](https://strapi.io/documentation/developer-docs/latest/setup-deployment-guides/installation/templates.html) are used to create various starters. A Strapi template is a pre-made Strapi configuration designed for a specific use case. It allows you to bootstrap a custom Strapi app. Here is an illustration to cement the concept.
![ Starter CMS(1).png](/uploads/Headless_Commerce_Summit_Headless_Commerce_No_you_don_t_have_to_ditch_your_CMS_1_5935b00dfc.png)


Starters pull data from the backend generated from a template and then display that in a frontend of your choice. If you'd like to look at our current list of starters, the [Strapi Starters](https://strapi.io/starters) page is an excellent place to start.

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

### How can you use Strapi Starters

The easiest way to get started with Strapi is to use our recently [released Starter CLI](https://strapi.io/blog/announcing-the-strapi-starter-cli). Usually, when you start a new Strapi project, we go with this command `npx create-strapi-app my-project --quickstart`, which sets up a blank Strapi application with no frontend. With the new Starter CLI, given that you know what you want to build is a blog with Gatsby, then all you have to do is type in the following command `npx create-strapi-starter my-project gatsby-blog`. This will set up a Strapi backend with collection types to suit the blog use case and relevant content. Besides the Strapi backend, the Starter CLI will also set up a Gatsby frontend. This Gatsby app will be able to make requests to your Strapi backend and fetch data to be displayed on its pages. You can then go ahead and tweak the backend and/or frontend to your liking and get your desired app to production much faster.


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

### How can you create your own Strapi Starters

For a long time, the only Starters you could use were those made by Strapi. This is no longer the case, as the template creation process has been made easier with the new template generation functionality of the Strapi CLI. This creation process is explained in detail in the Strapi Documentation on [templates](https://strapi.io/documentation/developer-docs/latest/setup-deployment-guides/installation/templates.html#creating-a-template).

To help you out, we put out a video on how to do that. It's well worth the watch. 😉

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

</br>

Once you've got the template generated, push it to GitHub, and then you can then start making a starter out of that template. User-created starters need two things to work; a starters folder with your frontend application (something [like this](https://github.com/strapi/strapi-starter-gatsby-corporate/tree/main/starter)) and a starter.json that references a Strapi template, either user-made or an official Strapi one. Your starter.json file should look like this.

```javascript
{
 "template": "https://github.com/<your-username>/<your-template-repo-name>"
}
```


### What's next for Strapi Starters

What's next? That's up to you! For starters (pun intended), we'd love to hear some feedback on the developer experience of creating and using Starters. We'd also love to see what Starters you make. When you do get to making these Starters, we'd love to share them with the Strapi community; if you'd like that, please add them to the [Starters page](https://strapi.io/starters). That said, we'll be adding more features to make the creation and use of Starters easier. We'll also be adding more use cases to our Starters and equipping Starters with the latest and greatest of Strapi features. Look out for all that :D

> **Please note:** Since we published this blog post, we released new versions of Strapi, and guides are outdated. Sorry for the inconvenience if it's the case. Please help us [by reporting it here](<https://github.com/strapi/community-content/issues/new/choose>). Other places to interact with the Strapi community are:



- [Resource Center](https://strapi.io/resource-center)

- [Try live demo](https://strapi.io/demo)

- [Join us on Discord](https://discord.strapi.io/)

- [Find help in our Forum](https://forum.strapi.io/)

- [Strapi on Youtube](https://www.youtube.com/c/Strapi/featured)

- [Try Enterprise Edition](https://strapi.io/enterprise)

Till next time, ciao!