As a remote-first company, distributed in different timezones Strapi chose to organize to employees, Strapiers, a Virtual Retreat! This article will go through creating and organizing an inclusive two days virtual retreat. 

Virtual Retreat: How to plan and host a memorable experience?

Join StrapiConf, the Second Online & Free Global User Conference for the Strapi community

Announcing StrapiConf 2022: Building Faster. Together.

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

What is Product Marketing? 

We are thrilled to announce the new blog section: "Strapi Life Blog." Meet the Strapiers stories, the role each Strapier plays, and what it is like to be part of building the rocket while flying it.

New Year, New Strapi Life Blog

Today, we’re thrilled to announce our partnership with Cloudflare through the Cloudflare Deploy Hooks for Strapi.

Announcing our Partnership with Cloudflare

Close to a year ago, we shared the news of our new community program; the Strapi Community Stars. Here is a glimpse of what they have been upto over the course of the year.




Announcing our latest batch of Strapi Stars

In this post we’re explaining the reasons we decided to open source our company Handbook and what it means for you. 

Open Sourcing our Company Handbook

Exactly 6 years ago today, the first lines of code were committed to the Strapi project repository on GitHub.

Celebrating Strapi’s 6th birthday

We are excited to announce the organization of the second edition of StrapiConf, the global user conference for the Strapi Community

Save the Date: StrapiConf 2022

Get all the latest Strapi updates, news and events.

Join our Newsletter

###### Last month, the Strapi team went up in the mountains into a superb chalet to brainstorm and find opportunities for the future of the project.

![](https://cdn-images-1.medium.com/max/2560/1*JGlSYEOTuQHusk5rBW0R9A.jpeg)
*Hiking to the top!*

Strapi has grown quite a bit since last year's [offsite in Marrakech.](https://twitter.com/strapijs/status/1050738321968783361) We are now a team of 10 with the [arrival of Maxime](https://twitter.com/strapijs/status/1146423971329576960) this July. As we scale in size, we felt the need to bring the team together to plan the upcoming months and to set the standards of our company culture.

Our goal for this offsite was to shape the future of Strapi. We are planning to be twice as many in a year, how will we scale? Where we will be in 2 years? We also worked to be more specific about the roadmap, the onboarding, and the company values.

[As we increase in numbers](https://twitter.com/aureliengeorget/status/1148952919137501184), the Strapi community must continue to enjoy using Strapi. This implies crystal-clear communication and transparent processes for users and contributors.

![](/uploads/90167DEB-ED37-4BBE-812B-A432F0D4049F.jpg_b96b8cc603.jpeg)
*Our beautiful office during the offsite.*

After we arrived at the chalet in [La Clusaz](https://www.google.com/maps/place/74220+La+Clusaz/@45.8982521,6.3953697,12z/data=!3m1!4b1!4m5!3m4!1s0x478bf071ee591289:0x408ab2ae4baa200!8m2!3d45.904427!4d6.423353) and settled in, [Pierre](https://twitter.com/pierre_burgy) explained what we hoped to accomplish by the end of our trip. We started each day as a team with workshops about different topics. [Soupette](https://github.com/soupette) had come up with the idea of splitting up into 3 teams for cooking the meals each day. Each day a different team was in charge of cooking lunch and dinner for the whole team!

Each work session started with a presentation of the situation and finished with shared thoughts, vision, and ideas, and then off to the cooking session.

## Highlights

### Vision and values

As our staff doubled in 6 months, one of the opening questions was how to ensure proper scaling and how to clarify the direction we are heading to the next 18 months.

Before the offsite, we had defined a number of challenges that we had recently faced as a team and also compiled feedback gathered from the community. We classified them in topics and dived into these with a collaborative session to come up with ideas and solutions.

![](https://cdn-images-1.medium.com/max/800/0*iR6ErzvGzd2zGc_V.jpg)

Having had the opportunity to think of the different types of challenges, the team came away with clear foundations to build on and explore on return from the offsite.

Here are some actions we decided to take:

- **Improve team communication and towards the community in terms of vision -** Strapi is born from the passion for making a product that will change the lives of thousands of people.
- **Define the company culture -** We often refer to characteristics that define the way we interact and the reasons we wake up every day. We need now to write them down, publish them for the community, and make them actionable.

### Release processes and communication

During the offsite, we planned a workshop about the Strapi product, the releases, and the way we communicate about them.

The main question we tried to answer during this workshop was :

**How do we improve the feature releases & the way we communicate on the product?**

This challenge seemed a bit wide, so we decided to split it into 3 different statements. Each group was assigned a statement and had 15 minutes to list related pain points. Here are the 3 statements on which we worked.

- **Have better communication.**
- **Have visible and understandable goals around the product.**
- **Set up processes that fit the team’s needs and improve the feature releases.**

After debating and choosing the 3 major pain points for each statement, each group had another 15 minutes to come up with concrete solutions to solve these pain points.

We came up with quite a few immediately actionable ideas.

For instance, we decided that sharing the roadmap to the community was not enough: it is essential to explain why we make decisions. This is the purpose of the [Monthly Update](https://blog.strapi.io/monthly-update-july-2019/), that we published a couple of weeks ago and of [our latest post about why we split the management of Admin users and End Users](https://blog.strapi.io/why-we-split-the-management-of-the-admin-users-and-end-users/).

## Activities

This off-site also gave us a fantastic opportunity to enjoy the beautiful landscapes of this part of [Haute-Savoie](https://en.wikipedia.org/wiki/Haute-Savoie) for our team-building activities.

We were able to discover canyoning, chill around the Annecy Lake, and see how we interact with each other as small cooking teams.

### Canyoning

For those who might have never heard this term, [canyoning](https://en.wikipedia.org/wiki/Canyoning) is traveling in canyons using a variety of techniques that may include other outdoor activities such as walking, scrambling, climbing, jumping, abseiling (rappelling), and swimming.

![](/uploads/P6260013--1-.jpg_aa2c5af59a.jpeg)

It was a first for some of us, and we all enjoyed it! For some of us, it was exciting to be challenged out of our comfort zone.

![](/uploads/P6260026--1-.jpg_7f40612059.jpeg)
*Canyoning with [Atmosphère Canyon](https://www.atmosphere-canyon.fr)*

### Cooking Sessions

Each day, one team of 3 was in charge of cooking lunch and dinner meals for a whole day!

It was an excellent opportunity to discover the secret recipes of each team. At Strapi, we love good food and enjoying good times around a lovely table.

Here are some pictures of the amazing dishes cooked by the team.

![](https://cdn-images-1.medium.com/max/800/1*1pTiEJlN1GdVjTWon1V6Cg.jpeg)
*Alexandre's home-made entremets.*
![](https://cdn-images-1.medium.com/max/800/1*KanF0Mozgg3hh0ccipCIgg.jpeg)

![](https://cdn-images-1.medium.com/max/800/1*UDuF-FRR5YLM9RJDWBOQiA.jpeg)
*Alexandre’s strawberry pie*

### Annecy Lake

Just before heading back to Paris, we finished the offsite with a beautiful moment around Annecy Lake. Afterward, and full of energy, it was off to Paris to deliver the best for the Strapi community!

![](/content/images/2019/07/6B58ED33-1B85-40AD-8CF2-8E707D5F238B-1.JPG)

### Learnings

- **Values matter.** Strapi is an open-source company and is driven by values like transparency, empathy or care. And we love jokes. And food. We will write down our company culture and open-source it to allow contributions from the community.
- **Communication is key.** We are committing to monthly updates explaining the latest decisions, features produced, or fixes. From an internal perspective, we are optimizing our time by using more asynchronous communication channels like GitHub repositories for company-related issues. The goal is to decrease the time spent in meetings without loss of information.
- [**We should eat our own dog food](https://en.wikipedia.org/wiki/Eating_your_own_dog_food).** Strapi will be more and more used internally. Non-technical team members will be paired with technical team members during **an internal hackathon** to create an app running with Strapi.

You can have a look at the pictures taken during the offsite on our Instagram account [here](http://instagram.com/strapijs). Don't forget to subscribe to keep in touch! 

*Strapi is hiring! Come and join us on our journey to reinvent the way content is managed and distributed. To see the job openings, it's [here](https://www.welcometothejungle.co/en/companies/strapi/jobs).*

*If you’ve enjoyed this post, please take a second to share it on Twitter. Got comments or questions? Hit the section below!*

the-strapi-team-offsite

The Strapi team goes offsite

### Introduction

Holding an in-person company retreat is a great way to strengthen the bonds within the team and have fun. However, as a remote-first company, distributed in different timezones (CET to PST) Strapi chose to organize to employees, Strapiers, a Virtual Retreat! 

In 2021, the People team launched not 1 but 2 virtual events! It took a lot of effort but gathering as a team to strengthen Strapiers connections and build a collective memory was priceless. Especially while being apart due to two years of a worldwide pandemic that also impacted our private and social lives.

This article will go through creating and organizing an inclusive two days virtual retreat that Strapiers enjoyed attending, as well as the lessons learned before, during, and after. We hope to inspire you!  

### What were we expecting the team to get out of this?

We started our process by dissecting our goals for the event. 

In 2021, Strapi reached an important step, being a 50+ team. It also meant that some Strapiers never had the chance to meet and know each other in person. 

1. Our first goal was to have people meet and strengthen/create team bonds.
2. It was also the perfect opportunity to celebrate an important and challenging milestone accomplished by the team with the [release of the V4](https://strapi.io/v4). Altogether, these two days were a breathing space in our daily rush and haste. We deliberately decided not to do workshops or anything related to business. 

### What were the main challenges?

We identified three main facets we had to be very careful with. 

1. Our team is distributed from the [CET to PST timezones](https://strapi.io/careers). When we started planning, we calculated how much time we could reasonably overlap. **The answer: 4 hours.** That meant that if we wanted our global team to be online together simultaneously, we could only plan events for our virtual retreat for 4 hours each day. We used this as an opportunity to offer a free morning or evening that could be spent with each team/squad, the family, friends, sleeping, reading, doing sport, ... Whatever the teammate felt for. 
2. Finding **inclusive and diverse activities** was challenging too. Some people are introverts, others need contact and prefer on-site events for example. We found a solution for some activities to be together (e.g. with a conference, blind test) and for others to propose three completely different activities simultaneously. Strapiers could pick the one they preferred with a different atmosphere. 
3. Another challenge we had was to **keep the pace and Momentum** while avoiding Zoom fatigue. We had breaks during the event, and we framed, for example, a 100 steps challenge to encourage people to go outside, have a walk and get some fresh air. We also combined in the schedule (I know you're eager to see it ☺️) activities using our hands (cooking, origami) and exercise of breathing or more rational activities (talk about digital wellness). 
    
![Capture_dcran_2021-12-20__09.58.30.png](/uploads/Capture_dcran_2021_12_20_09_58_30_bf6ada0990.png)

### What are our tips and tricks to have a memorable experience?

Some do’s that could help you! 

1. We asked via a survey what Strapiers wanted to do during the 2 days months before. 
    
[Q4 Virtual Retreat survey.pdf](https://s3.us-west-2.amazonaws.com/secure.notion-static.com/c08fe233-fda9-4254-886d-82a5620f8847/Q4_Virtual_Retreat_survey.pdf?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIAT73L2G45EIPT3X45%2F20220214%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20220214T110347Z&X-Amz-Expires=86400&X-Amz-Signature=42dfd71f76b60dd18fcd6ec09c0bf4951808b29d40a93de6a78951e4451f09e1&X-Amz-SignedHeaders=host&response-content-disposition=filename%20%3D%22Q4%2520Virtual%2520Retreat%2520survey.pdf%22&x-id=GetObject)
    
We also had feedback from previous virtual events to help us continue improving. 
    
2. We invited Strapiers to lead some activities. It encourages people to be engaged and strengthen/create bonds instead of having only intervention from external speakers or the People team. As a multicultural and diverse team, it is also an excellent opportunity to share Strapiers’ cultures, hobbies, skills, etc.

3. Anticipation and organization were also crucial to having a smooth and captivating event.

    a. Before the event


-  We shared the schedule with the team two weeks before the event;
- We created Zoom links for each activity;
- We prepared who would say what, at what time;
    
    b. During the event
    

 - We shared, again and again, links to connect, and we had a timekeeper. The objective was to be effortless for participants, and they just had to care about having fun!
 - We organized three activities to let Strapiers choose what they’d prefer to do. Someone from the People team was during that time jumping from one room to another to check that everything was going well.

### How did we communicate internally and externally?

Naturally, communication played a considerable part in the outcome of the experience. 

1. We created a slack channel dedicated to the event and shared every single day for 2 weeks some games, information about the event, teased what will happen. We wanted Strapiers to be impatient to spend these two days together! 

![Screen Shot 2022-02-14 at 12.07.48.png](/uploads/Screen_Shot_2022_02_14_at_12_07_48_b23ae2e756.png)

2. We shared the agenda during those two weeks after some teasing. Here it is! (Is it the moment you were all looking for?!)

![Screen Shot 2022-02-14 at 12.08.27.png](/uploads/Screen_Shot_2022_02_14_at_12_08_27_7199ea8afb.png)

3. When there were external speakers, we did a brief before with each one of them to explain Strapi’s culture, values, inclusive communication,... We wanted to be sure that speakers will adapt to Strapi and Strapiers (some of them did it and some no...)

### Was it a success?

Overall, the event was a success, and we had startling feedback from the team! We measured its NPS: 82! 

![Screen Shot 2022-02-14 at 12.09.44.png](/uploads/Screen_Shot_2022_02_14_at_12_09_44_206f782639.png)

It’s always challenging to find a balance between activities and needs from everyone. It requests a high level of organization, communication, and to expect the unexpected.


large_LaurinesArticle_.png

medium_LaurinesArticle_.png

small_LaurinesArticle_.png

thumbnail_LaurinesArticle_.png

LaurinesArticle_.png

Discover how the Strapi marketing team is using Strapi to manage the content of the website you are currently browsing.

How the Strapi Marketing Team Uses Strapi

As a rapidly growing company, we’re constantly reviewing our internal processes to make sure they scale and are fully aligned with our values and the team needs. Transparency and Care are two of our [values](https://strapi.io/careers) and we want to live by them by sharing our [company handbook](https://handbook.strapi.io), explaining the reasons why we decided to make it public and how everyone can use it going forward. 


## Our journey to remote-first

In less than 2 years, the Strapi team grew from a team of 7 people based in Paris, France to a remote-first company with 50 team members affectionately called “Strapiers" spread across 7 countries in 4 continents. While Covid-19 acted as a major forcing function to embrace remote work, our ambition to build a global distributed workforce also led to some growing challenges.

Inspired by the success of fully remote companies like [GitLab](https://about.gitlab.com/handbook/) or [HashiCorp](https://www.hashicorp.com/tao-of-hashicorp), the Strapi team wants to embrace a modern way of working that provides the freedom and caring setup needed to build a healthy business and both attract and retain the best talents. Our first big step in that direction was to start hiring employees outside of France. This meant adapting to the different time zones and shifting to more asynchronous communication. The second challenge was to hire our Head of People & Talent to help structure our hiring processes, people policies, ensure all employees feel included and treated equally regardless of their location and most importantly to cement our company culture as a remote-first company. As an example, we decided to rename our office in Paris to co-working space and limit the number of days employees can come to the office to prevent the creation of a separate office culture. 

From that point forward, there was no going back. Communication methods and decision making processes had to evolve drastically. That’s when we started to document and structure the internal knowledge to facilitate onboarding of Strapiers and build the foundation that would scale with a growing team. 


## Open Source in our DNA

Strapi started as an open source project back in 2015. Today, the Strapi GitHub repository counts 40K stars and is ranked the 163 most popular repository among the 28 million public on GitHub as of October 2021. We are truly humbled by this and realized that none of this would be possible without the support of the Strapi open source community. 

So being open-source has been part of our DNA from day 1. It's about transparency, care, humility and data privacy. As a company, we couldn’t be more aligned with these values. Not just through Strapi, but through contributions to other open source projects we rely on such as StoryBook, Webpack, and Babel. 

Although Open Source is deeply rooted in our company culture, it does not mean we are perfect “open source citizens”. We still have plenty of room for improvement to be more transparent and inclusive with the Strapi user community. In addition to the benefits in terms of hiring, onboarding and efficiency, open sourcing our [company handbook](https://handbook.strapi.io) is also a way to give back, become more transparent in the eyes of the Strapi community and hold ourselves accountable to higher standards. 


## What does it mean for you? 

As a community member, it means that you know exactly what we stand for, the vision and values that drive us and the methodologies we follow from Product Development to Marketing or Sales. 

As an investor, partner, prospect or customer, it means that you know exactly who you are or might be doing business with. From high level company values and driving principles to more granular tech stack decisions and processes, we’re literally an open book. 

As a potential candidate, it means that you can look for the information you need to know exactly what to expect and if you like the way we operate. No more surprises. By the way, [we’re hiring](https://strapi.io/careers#open-positionshttps://strapi.io/careers#open-positions)! 

As an employee, it means that you are working at a radically transparent company. No more wondering if that information can be shared outside of Strapi, if it’s in the handbook it is public information. You have visibility over the decision making process and who are the directly responsible individuals for each topic or program. 


## Conclusion 

This is the first iteration of this [company handbook](https://handbook.strapi.io). We’re committed to making more and more pages public overtime as every team reviews carefully existing content to make sure it’s safe to share, up to date and up to our company standards. 

We’d like to thank GitLab for their leadership on this topic as their public handbook has been a source of inspiration for many years. Our hope is that one day, others will find the Strapi handbook as useful as we found the GitLab handbook to be. 

Have feedback or ideas for our [Handbook](https://handbook.strapi.io)? Join the conversation in the comments section below! 


Derrick Mehaffy is the most active member of the Strapi community. A few months back he [shared with us his story](https://strapi.io/blog/community-spotlight-derrick-mehaffy ) of how we went from a simple Strapi user to a community expert. Today we are more than happy to welcome Derrick to the Strapi family! 

##  Why did you join Strapi?

I wanted to push myself outside my comfort zone and into a field that I only really started to dive into over the past few years after using Strapi on personal projects. Over that time frame, working with and around the other users as well as the [Strapi team](https://strapi.io/about-us) I really started to feel welcomed into the Strapi ecosystem. 

At some point, people began asking why don't I apply for a position, and I never really had a good answer to that question. I think over the years, finding myself spending more and more time talking with so many people, helping others, and solving problems I started to feel like I was already a part of the Strapi family and I decided why not give it my best shot and apply for a position.

## What will you be working on? 

My primary role within Strapi as a Solutions Engineer will be just that, engineering solutions. Be that answering community questions on our various platforms, working with enterprise customers, or working with all the various teams within Strapi to help unify us as a company, a community, and an overall family of like-minded developers, content creators, and business owners.

## What advice can you give to community members who want to get involved with Strapi? 

The absolute must for getting started with Strapi would be the [documentation](https://strapi.io/documentation/v3.x/getting-started/quick-start.html), as someone coming from almost no development background, the documentation has been my key tool while troubleshooting. 

Once you have a good understanding of how key parts of Strapi function at the logical level, my suggestion would be to just dig into the source code. There are parts you may not fully understand from the start (I myself was in that position) but as you continue learning about how Strapi functions you will begin to see just how powerful of a tool it can be for many of your projects.

If you are new to Strapi, just give it a try!
 
Take a look at the [Getting Started guide](https://strapi.io/documentation/3.0.0-beta.x/getting-started/quick-start.html#_1-install-strapi-globally) to jump on board, or get started with the following command line:
 
`yarn create strapi-app my-app --quickstart`
 
or
 
`npx create-strapi-app my-project --quickstart`

## Get involved
 
Check out our [public product roadmap](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration) to see what features we’ll be working on next.
Don’t see a feature you’d like in the backlog? Feel free to [submit new feature requests](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration) or even better, [start contributing](https://github.com/strapi/strapi/blob/master/CONTRIBUTING.md) to Strapi on GitHub. All contributions and users are welcome!


Welcome Derrick

Welcoming Derrick to the Strapi team 

That's it, we are in the middle of winter, it is very cold and the restaurants are unfortunately still closed. But that will not prevent our great [Live demo](https://strapi.io/demo) from receiving updates!
Here is what was added in the last version of [Foodadvisor](https://github.com/strapi/foodadvisor)

![Gif snow](https://media.giphy.com/media/3oriNScTbEzEVoR1Is/giphy.gif)

## Universal pages

[Daniel Madalitso Phiri](https://twitter.com/malgamves) added the implementation of a new very useful collection type to the project: [Universals](https://github.com/strapi/foodadvisor/pull/67) But what is that for?
Well, it simply allows you to create pages on the fly directly in the admin panel. You just need to structure your frontend appropriately so that you just have to create your pages afterwards! Allowing content managers to create pages on the fly is a must have for any [headless cms](https://strapi.io/headless-cms-guide). This is why it is important to show that it is quite feasible and easy!

Indeed we use this collection type internally on our [website](https://strapi.io) and it turns out to be very useful when we want to quickly deploy new pages on it. Pair that with a [Webhook](https://strapi.io/blog/webhooks) building your favorite [Nuxt.js](https://nuxtjs.org/), [Gatsby](https://www.gatsbyjs.com/) or [Next.js](https://nextjs.org/) frontend on [Vercel](https://vercel.com/) and you are good to go!

![Gif rocket](https://media.giphy.com/media/UVH5ew36nACis18ocZ/giphy.gif)

The following pages are **universals** on our website:

  - [https://strapi.io/demo](https://strapi.io/demo)
  - [https://strapi.io/headless-cms-guide](https://strapi.io/headless-cms-guide)
  - [https://strapi.io/faq](https://strapi.io/faq) and 47 more...

## Upgrade Strapi version to 3.4.6

The version of Strapi has been upgraded to the latest to this date.
More information here: [https://github.com/strapi/strapi/releases](https://github.com/strapi/strapi/releases)

## Guided Tour

We wanted to implement a guided tour to take you by the hand at the start of the demo. Relatively simple and fast it will show you the important parts of the admin allowing you to create your content-types and subsequently your content.

We are using [reactour](https://github.com/elrumordelaluz/reactour), and we have made a guided-tour plugin in the app. You can see how it works here: [https://github.com/strapi/foodadvisor/tree/master/api/plugins/guided-tour](https://github.com/strapi/foodadvisor/tree/master/api/plugins/guided-tour)
Feel free to give it a try or event contribute to it ;)

## Front-end on Codesandbox

When you'll ask for a live demo [here](https://strapi.io/demo), you'll receive an email with the link of your Strapi instance. We also included a [codesandbox](https://codesandbox.io/) link that will open a front-end that can be connected to your demo.

Once the front-end is open on codesandbox, you'll need to add an environment variable in the `.env` file to connect it to your Strapi instance.
  - Open the `.env` file.
  - Add the following variable: `REACT_APP_BACKEND_URL=<URL-OF-DEMO-WITHOUT-TRAILING-SLASH>`.
  - Save.

![Capture d’écran 2021-02-11 à 18.50.42.png](/uploads/Capture_d_ecran_2021_02_11_a_18_50_42_4900ed7c63.png)

If you add a new restaurant for example, you'll be able to see it on your sandbox after reloading your app!

## What you would like to see

We definitely take feedback regarding our live demo. You can write down in the comments what you would like to have in the demo, what you liked if you were able to try it or what you did not like.
See you at the next update!


Try Foodadvisor live in just a few clicks: https://strapi.io/demo
Try Foodadvisor locally on your machine: `git clone https://github.com/strapi/foodadvisor.git`

---

Get started with Strapi by creating a project using a [starter](https://strapi.io/starters) or trying our [live demo](https://strapi.io/demo). Also, consult our [forum](https://forum.strapi.io) if you have any questions. We will be there to help you.
<p align="center">
<a href="https://strapi.io/documentation/developer-docs/latest/getting-started/quick-start.html#_1-install-strapi-and-create-a-new-project">
<img src="https://assets.strapi.io/uploads/Get_Started_e4e026ce55.svg#small" />
</a>
</p>
See you soon!

large_Foodadvisor Updates (1).jpg

medium_Foodadvisor Updates (1).jpg

small_Foodadvisor Updates (1).jpg

thumbnail_Foodadvisor Updates (1).jpg

Foodadvisor Updates (1).jpg

If you are a student or working for a non-profit organization or an open-source project, this news will certainly interest you.

With the help of amazing open-source contributors, we’re on a mission to develop the most customizable headless CMS on the market, empowering developers, and content managers to create millions of applications. 


Today, we are very happy to announce that Strapi is committed to supporting students, non-profit organizations as well as open-source projects by offering them [Strapi Enterprise](https://strapi.io/enterprise) Bronze Edition.

![Excited GIF](https://media.giphy.com/media/8rFgzA7aBR0aomiOMj/giphy.gif)

With this free bronze plan, you’ll be able to benefit from advanced features that are available now i.e Role-Based Access Control and coming soon i.e SSO Authorization, and Content Internationalization. 

### Student Qualification Criteria

If you are a student and wish to benefit from our Enterprise Edition Bronze plan, you must: 

  - Provide a copy of your student ID
  - Register with your student email address

After verifications, we will send you the necessary to take advantage of your free offer. 

[Apply Now](https://strapi.io/free-enterprise-edition)


### Non-profit organization Qualification Criteria

As a non-profit organization, you can also benefit from our offer.To qualify from this program, you must: 

  - Be an independent nonprofit 
  - Provide proof of your non-commercial status 
  - Link to your organization’s website or web presence 


[Apply Now](https://strapi.io/free-enterprise-edition)


### OSS Qualification Criteria projects

Finally, if you maintain an open-source project just like [Strapi](https://github.com/strapi/strapi), you can also enjoy a Bronze plan for free. To qualify from this program, you must: 

  - Be public and non-commercial
  - Meet the Open Source Initiative (OSI) definition (shown [here](https://opensource.org/docs/osd)), including definitions for free distribution, source code, derived works, the integrity of source code, licensing, and no tolerance for discrimination 
  - Code of your Strapi project must be publicly available.

All you have to do is to fill out the application form below. After verification, we will send you the necessary to take advantage of your free offer. 

[Apply Now](https://strapi.io/free-enterprise-edition)

An email will be sent to you at the end of your subscription in order to proceed with the renewal.

### Share the Strapi Love 

As a sign of appreciation for this free software, our hope is that the community users agree to become a public reference and display links to Strapi on all the appropriate pages.  

We are once again very happy to be able to provide you with the most customizable solution to carry out your web projects! Besides, don't hesitate to add your creations to our [Showcase](https://strapi.io/showcases)!

See you soon!


- [Get Strapi up and running in 3 minutes](https://strapi.io/documentation/v3.x/getting-started/quick-start.html)
- [Get access to a hosted Strapi with sample data](https://strapi.io/demo)
- [Discover Enterprise Edition](https://strapi.io/enterprise)



Are you a student? Non-profit? OSS project? Upgrade your existing Strapi project to the Bronze Edition for free.

 Announcing Free Strapi Enterprise Editions for Students, Open Source and Non-Profits

> This tutorials is outdated since it is for Strapi v3. We redirect you to the part of our documentation concerning [the creation of a new WYSIWYG field in the admin panel](https://docs.strapi.io/developer-docs/latest/guides/registering-a-field-in-admin.html#setting-up-the-plugin)

Another new WYSIWYG editor that allows you to replace the default one on Strapi! 

Well this time, I would not need to explain in detail how to replace it by yourself because it turns out that [Fagbokforlaget](https://github.com/fagbokforlaget), which is a Norwegian publishing company that publishes nonfiction works and teaching aids for instruction at various levels, already made an [npm package](https://www.npmjs.com/package/@forlagshuset/strapi-plugin-wysiwyg-toastui) you can directly add to your Strapi project in order to have a wonderful Toast UI editor in your admin.

This editor is great as it implements real-time previsualization of what you are writing.
This package is listed on our [awesome Strapi](https://github.com/strapi/awesome-strapi) repository but I find it important to write a blog post because many of you want to replace the default editor but do not know the existence of this Github repository.

However, I will explain the code of this package. This is exactly like we did for manually installing [Quill editor](https://strapi.io/blog/how-to-change-the-default-wysiwy-to-quill-editor).

It's very simple to get started. Head into an existing Strapi project and add the package via npm or yarn:

```bash
npm i --save strapi-plugin-wysiwyg-toastui
# or
yarn add strapi-plugin-wysiwyg-toastui
```

Perfect, all you have to do is build and launch your Strapi application:

```
yarn build
yarn develop
# or
npm run build
npm run develop
```

You can now edit your Rich Text content using the Toast UI editor!

Let's take a closer look at how they made it...

You can observe the package code by looking at the following path:

`. /node_modules/strapi-plugin-wysiwyg-toastui/admin/src/components`

We can see that 3 components have been created:

## MediaLib component

```js
import React, {useEffect, useState} from 'react';
import {useStrapi, prefixFileUrlWithBackendUrl} from 'strapi-helper-plugin';
import PropTypes from 'prop-types';

const MediaLib = ({isOpen, onChange, onToggle}) => {
  const {
    strapi: {
      componentApi: {getComponent},
    },
  } = useStrapi ();
  const [data, setData] = useState (null);
  const [isDisplayed, setIsDisplayed] = useState (false);

  useEffect (() => {
    if (isOpen) {
      setIsDisplayed (true);
    }
  }, [isOpen]);

  const Component = getComponent ('media-library'). Component;

  const handleInputChange = data => {
    if (data) {
      const {url} = data;

      setData ({... data, url: prefixFileUrlWithBackendUrl (url)});
    }
  };

  const handleClosed = () => {
    if (data) {
      onChange (data);
    }

    setData (null);
    setIsDisplayed (false);
  };

  if (Component && isDisplayed) {
    return (
      <Component
        allowedTypes = {['images', 'videos', 'files']}
        isOpen = {isOpen}
        multiple = {false}
        noNavigation
        onClosed = {handleClosed}
        onInputMediaChange = {handleInputChange}
        onToggle = {onToggle}
      />
    );
  }

  return null;
};

MediaLib.defaultProps = {
  isOpen: false,
  onChange: () => {},
  onToggle: () => {},
};

MediaLib.propTypes = {
  isOpen: PropTypes.bool,
  onChange: PropTypes.func,
  onToggle: PropTypes.func,
};

export default MediaLib;
```

This component allows you to use the Media Library and will be called in the editor component in order to directly use images from the Media Library.
Nothing much! Let's see the second component.

## WYSIWYG component

```js
/**
 *
 * Wysiwyg
 *
 */

import React from 'react';
import PropTypes from 'prop-types';
import { isEmpty, isFunction } from 'lodash';
import cn from 'classnames';

import { Description, ErrorMessage, Label } from '@buffetjs/styles';
import { Error } from '@buffetjs/core';

import Editor from '../TOASTUI';
import Wrapper from './Wrapper';

class Wysiwyg extends React.Component {

  render() {
    const {
      autoFocus,
      className,
      deactivateErrorHighlight,
      disabled,
      error: inputError,
      inputClassName,
      inputDescription,
      inputStyle,
      label,
      name,
      onBlur: handleBlur,
      onChange,
      placeholder,
      resetProps,
      style,
      tabIndex,
      validations,
      value,
      ...rest
    } = this.props;

    return (
      <Error
        inputError={inputError}
        name={name}
        type="text"
        validations={validations}
      >
        {({ canCheck, onBlur, error, dispatch }) => {
          const hasError = error && error !== null;

          return (
            <Wrapper
              className={`${cn(!isEmpty(className) && className)} ${
                hasError ? 'bordered' : ''
              }`}
              style={style}
            >
              <Label htmlFor={name}>{label}</Label>
              <Editor
                {...rest}
                autoFocus={autoFocus}
                className={inputClassName}
                disabled={disabled}
                deactivateErrorHighlight={deactivateErrorHighlight}
                error={hasError}
                name={name}
                onBlur={isFunction(handleBlur) ? handleBlur : onBlur}
                onChange={e => {
                  if (!canCheck) {
                    dispatch({
                      type: 'SET_CHECK',
                    });
                  }

                  dispatch({
                    type: 'SET_ERROR',
                    error: null,
                  });
                  onChange(e);
                }}
                placeholder={placeholder}
                resetProps={resetProps}
                style={inputStyle}
                tabIndex={tabIndex}
                value={value}
              />
              {!hasError && inputDescription && (
                <Description>{inputDescription}</Description>
              )}
              {hasError && <ErrorMessage>{error}</ErrorMessage>}
            </Wrapper>
          );
        }}
      </Error>
    );
  }
}

Wysiwyg.defaultProps = {
  autoFocus: false,
  className: '',
  deactivateErrorHighlight: false,
  didCheckErrors: false,
  disabled: false,
  error: null,
  inputClassName: '',
  inputDescription: '',
  inputStyle: {},
  label: '',
  onBlur: false,
  placeholder: '',
  resetProps: false,
  style: {},
  tabIndex: '0',
  validations: {},
  value: null,
};

Wysiwyg.propTypes = {
  autoFocus: PropTypes.bool,
  className: PropTypes.string,
  deactivateErrorHighlight: PropTypes.bool,
  didCheckErrors: PropTypes.bool,
  disabled: PropTypes.bool,
  error: PropTypes.string,
  inputClassName: PropTypes.string,
  inputDescription: PropTypes.oneOfType([
    PropTypes.string,
    PropTypes.func,
    PropTypes.shape({
      id: PropTypes.string,
      params: PropTypes.object,
    }),
  ]),
  inputStyle: PropTypes.object,
  label: PropTypes.oneOfType([
    PropTypes.string,
    PropTypes.func,
    PropTypes.shape({
      id: PropTypes.string,
      params: PropTypes.object,
    }),
  ]),
  name: PropTypes.string.isRequired,
  onBlur: PropTypes.oneOfType([PropTypes.bool, PropTypes.func]),
  onChange: PropTypes.func.isRequired,
  placeholder: PropTypes.string,
  resetProps: PropTypes.bool,
  style: PropTypes.object,
  tabIndex: PropTypes.string,
  validations: PropTypes.object,
  value: PropTypes.string,
};

export default Wysiwyg;
```

This component will wrap the Toast UI editor with a label and the errors.
You can see that the index.js file is not alone. There is also a Wrapper.js file containing some style using styled-components.

```js
import styled from 'styled-components';

const Wrapper = styled.div`
  padding-bottom: 2.8rem;
  font-size: 1.3rem;
  font-family: 'Lato';
  label {
    display: block;
    margin-bottom: 1rem;
  }
  &.bordered {
    .editorWrapper {
      border-color: red;
    }
  }
  > div + p {
    width: 100%;
    padding-top: 12px;
    font-size: 1.2rem;
    line-height: normal;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    margin-bottom: -9px;
  }
`;

export default Wrapper;
```

Now, the final component which is the one for the Toast UI editor itself!

## ToastUI component

```js
import React from 'react';
import PropTypes from 'prop-types';

import '@toast-ui/editor/dist/toastui-editor.css';
import 'codemirror/lib/codemirror.css';
import { Editor } from '@toast-ui/react-editor';
import { Button } from '@buffetjs/core';

import MediaLib from '../MediaLib';

class TOIEditor extends React.Component {
  editorRef = React.createRef();

  constructor(props) {
    super(props);
    this.height = "400px";
    this.initialEditType = "markdown";
    this.previewStyle = "vertical";
    this.state = { isOpen : false };
    this.handleToggle = this.handleToggle.bind(this);
  }

  componentDidMount() {
    const editor = this.editorRef.current.getInstance();
    const toolbar = editor.getUI().getToolbar();

    editor.eventManager.addEventType('insertMediaButton');
    editor.eventManager.listen('insertMediaButton', () => {
      this.handleToggle();
    } );

    toolbar.insertItem(0, {
      type: 'button',
      options: {
        className: 'first tui-image',
        event: 'insertMediaButton',
        tooltip: 'Insert Media',
        text: '@',
      }
    });
  }

  componentDidUpdate() {
    // Bug fix, where switch button become submit type - editor bug
    const elements = document.getElementsByClassName('te-switch-button');
    if ( elements.length ) {
      elements[0].setAttribute('type','button');
      elements[1].setAttribute('type','button');
    }
  }

  handleChange = data => {
    let value = this.props.value;
    let editor_instance = this.editorRef.current.getInstance();
    if (data.mime.includes('image')) {
      editor_instance.exec('AddImage', { 'altText': data.caption, 'imageUrl': data.url } );
    }
    else {
      editor_instance.exec('AddLink', { 'linkText': data.name, 'url': data.url } );
    }
  };

  handleToggle = () => this.setState({ isOpen : !this.state.isOpen });

  render() {
    return (
      <>
        <Editor
          previewStyle={this.previewStyle}
          height={this.height}
          initialEditType={this.initialEditType}
          initialValue={this.props.value}
          ref={this.editorRef}
          usageStatistics={false}
          onChange={(event) => {
            this.props.onChange({
              target: {
                value: this.editorRef.current.getInstance().getMarkdown(),
                name: this.props.name,
                type: 'textarea',
              },
            });
          }}
          toolbarItems={[
            'heading',
            'bold',
            'italic',
            'strike',
            'divider',
            'hr',
            'quote',
            'divider',
            'ul',
            'ol',
            'task',
            'indent',
            'outdent',
            'divider',
            'table',
            'link',
            'divider',
            'code',
            'codeblock',
            'divider',
          ]}
        />

        <MediaLib onToggle={this.handleToggle} isOpen={this.state.isOpen} onChange={this.handleChange}/>
      </>
    );
  }

}

export default TOIEditor;
```

As you understood, this component is the implementation of the new WYSIWYG which is simply using the Media Library.

That's it for this article which, I hope, will have introduced you to a very useful and especially great package.

![strapi-toast-ui](/uploads/strapi_toast_ui_352c444ab6.png)

## To learn more about other WYSIWYG 

  - [Replace the default WYSIWYG by CKEditor](https://strapi.io/documentation/developer-docs/latest/guides/registering-a-field-in-admin.html#introduction).
  - [Replace the default WYSIWYG by Quill Editor](https://strapi.io/blog/how-to-change-the-default-wysiwy-to-quill-editor).

> **Please note:** Since we initially published this blog post, we released new versions of Strapi and tutorials may be 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).

 ---

Get started with Strapi by creating a project, using a starter or trying our instant live demo. Also, consult our forum if you have any questions. We will be there to help you.

See you soon!


An npm package let you the possibility to replace the default WYSIWYG editor in Strapi by Toast UI editor. Customize your headless cms with custom WYSIWYG editors.

Change the default WYSIWYG to Toast UI editor

Use Strapi to scrape the web. Learn how you can collect data on websites using your favorite headless CMS, Puppeteer and Cheerio.

Web scraping with Strapi

You might also be interested in...

Foodadvisor Updates February 2021

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!

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

large_announcing-strapi-4m-seed-funding-round

medium_announcing-strapi-4m-seed-funding-round

small_announcing-strapi-4m-seed-funding-round

thumbnail_announcing-strapi-4m-seed-funding-round

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

![Strapi 2018](/uploads/New-Year---2018.jpg_500f7d77e7.jpeg)

Entering 2019, [Strapi](https://strapi.io) is leading the charge in making it the year where the Headless CMS space matures and becomes the standard way for individuals and companies to build their sites and apps. Strapi is already followed by countless proprietary, paid services and products hoping to capitalize on this next evolution of software development. Yet Strapi remains committed and will continue to lead this space by being the open sourced solution for serious developers wanting to control their data, deployment and tech stack.

If 2018 saw the rise and acceptance of GraphQL, THE missing link to truly allowing complete Headless CMS implementation; then in 2019 all companies achieve their destiny and liberate themselves from the reliance on monolithic applications, data constraints, wasted developer time and resources. Developing efficient API first applications is now possible. Strapi fills the gap of application management. You build the app or site, and managing it is now possible for anyone on your team.

So, first of all, Happy New Year! The curtain closed for 2018. As we start in 2019 we wanted to share a few statistics, events and announcements about the things we've built last year and prepared for the next. 

Over the last 12 months, Strapi grew:

 - from alpha 7 to **[alpha 17](https://github.com/strapi/strapi/releases)** 🏗
 - from 2,500 to **[15,000 downloads](https://npm-stat.com/charts.html?package=strapi&from=2016-12-26&to=2018-12-26) per month** 💻
 - from 2,000 to **[10,000 stars on GitHub](https://www.timqian.com/star-history/#strapi/strapi)** 🌟 ([give yours!](https://github.com/strapi/strapi))
 - from 27 to 173 **[contributors](https://github.com/strapi/strapi/graphs/contributors)** 🙌
 - from 2 to 14 **[translations](https://github.com/strapi/strapi/tree/master/packages/strapi-admin/admin/src/translations)** 🗣
 - from 4 to 6 **people on the team** 👨‍👩‍👧‍👦

Users downloaded Strapi 120K times in 2018, vs. 19K times in 2017. It is now used by thousands of companies the world over. Companies committed to full control of their data, security and their tech stack. We are proud to count a growing number of web agencies and freelancers who migrated to Strapi. They delivered their projects faster and maintained future security over their stack.

The numbers speak for themselves. 2018 was super exciting and made Strapi **the most advanced open-source, Node.js based, Headless CMS**!

Strapi takes over the Headless CMS space in 2019, by section:

## 2018 achievements 👀

Let’s look at our most important achievements for 2018!

### Putting the community first

> Behind every project, there is a team. Behind every open source project, there is a community.

Everything started with a very community-oriented action: the Vote page release. As an open-source project, we strongly believe in collective intelligence. Since your opinion is the one that matters, we published the Vote page, it lists a features backlog and lets you upvote the ones you want most.

![](/uploads/Screenshot-2019-01-03-at-11.34.16.png_7474a04ea0.png)

Later in the year though, we reached the limit of this solution to properly draw the roadmap. So, we [migrated to Product Board](https://portal.productboard.com/strapi/), where you still can vote but also comment on features and fully explore the [roadmap](https://portal.productboard.com/strapi/tabs/3-planned).

### Product improvements

With almost one release per month, your favorite open source Headless CMS has been fleshed out:

 - [Alpha 9](https://blog.strapi.io/release-v3-alpha-9/): Authentication with providers, Email templates customisation, Unique Email Signup.
 - [Alpha 10](https://blog.strapi.io/release-v3-alpha-10/): Settings in Database, rewrite Input Library.
 - [Alpha 11](https://blog.strapi.io/release-v3-alpha-11-file-upload/): File Upload.
 - [Alpha 12](https://blog.strapi.io/v3-alpha-12-graphql-rich-text-editor-redesigned-dashboard/): GraphQL, Rich Text Editor and redesigned Dashboard.
 - [Alpha 12.5](https://blog.strapi.io/release-v3-alpha-12-5-search-filters-bulk-actions/): Search, Filters & Bulk Actions.
 - [API Documentation](https://blog.strapi.io/api-documentation-plugin/) (Swagger) plugin.

**File Upload, GraphQL, Rich Text Editor and API Documentation** have probably been the most anticipated features (a direct result of the new Vote page).

<blockquote class="twitter-tweet" data-lang="en"><p lang="und" dir="ltr"> <a href="https://t.co/BNgcw2ej0o">pic.twitter.com/BNgcw2ej0o</a></p>&mdash; Swagger (@SwaggerApi) <a href="https://twitter.com/SwaggerApi/status/1075783636568424448?ref_src=twsrc%5Etfw">December 20, 2018</a></blockquote>
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

---

### Content

Offering a good product is great, helping you to use it is even better. With that in mind, we produced a lot of content, both by the team and the community. Here's a summary of your most appreciated tutorials and articles:

 - [Building a blog with Gatsby and Strapi](https://blog.strapi.io/building-a-static-website-using-gatsby-and-strapi/).
 - [Deploying a Strapi API on Heroku](https://blog.strapi.io/deploying-a-strapi-api-on-heroku/).
 - [🍝 Cooking a Deliveroo clone with Nuxt (Vue.js), GraphQL, Strapi and Stripe](https://blog.strapi.io/cooking-a-deliveroo-clone-with-nuxt-vue-js-graphql-strapi-and-stripe-setup-part-1-7/). Thank you Ryan for [adapting it to Next](https://blog.strapi.io/strapi-next-setup/)!
 - [How to deploy a Strapi API on Ubuntu 16.04](https://blog.strapi.io/how-to-deploy-a-strapi-application/).
 - [Building a static blog using Jekyll and Strapi](https://blog.strapi.io/building-a-static-website-using-jekyll-and-strapi/).

<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">&quot;Building a static blog using <a href="https://twitter.com/gatsbyjs?ref_src=twsrc%5Etfw">@gatsbyjs</a> and <a href="https://twitter.com/strapijs?ref_src=twsrc%5Etfw">@strapijs</a>&quot;<br><br>Updated with gatsby-image, especially thanks to <a href="https://twitter.com/_rezof?ref_src=twsrc%5Etfw">@_rezof</a>, <a href="https://twitter.com/RSchiefer?ref_src=twsrc%5Etfw">@rschiefer</a> &amp; <a href="https://twitter.com/_Deve__?ref_src=twsrc%5Etfw">@_Deve__</a>!<a href="https://t.co/sahvB6hPVB">https://t.co/sahvB6hPVB</a></p>&mdash; Strapi (@strapijs) <a href="https://twitter.com/strapijs/status/1057594016039137281?ref_src=twsrc%5Etfw">October 31, 2018</a></blockquote>
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

---

### Making the project sustainable

As you may know, we raised some money this summer. This is great news for growing the team, ensuring the project is better known and, more importantly, ensuring its sustainability!

The best way to be sustainable is, of course, to have some revenue. This is why we ran some tests on the website this summer. The results of these tests were very positive. Rest assured, open source is a key value for us, and this is why Strapi is and will always be open source.

### Focus on Headless CMS

Strapi has always been about APIs, proof is the origin of its name: Boot**strap** your **API** (at this moment you suddenly discover the origin of the name 😉).

For a long time, we have considered Strapi as a "Node.js framework with an Admin Panel", or even a "Content Management Framework"; neither is clear. But the API area is a very large one. So, to be relevant, we had to be more specific.

For that reason, we finally asked you - users, contributors, followers - to define Strapi with your own words. This following reply is probably the most representative we received (feel free to add yours)!

<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">Self-hosted headless JavaScript CMS with a pretty admin panel and a lightweight API</p>&mdash; Mustafa Hanif (@MustafaHanif8) <a href="https://twitter.com/MustafaHanif8/status/1033282432865382400?ref_src=twsrc%5Etfw">August 25, 2018</a></blockquote>
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

---

Considering Strapi as a CMS was at first hard for us because it sounded restrictive. But more than 50% of you use Strapi as a CMS, and the CMS universe needed a second big bang.

Previous generation CMS's (yes WordPress, we are thinking about you), filled a need to display and manage web pages (the head). But during the last few years, the number of devices exploded. From computers to smartphones, from smartwatches to IoT devices, content is now displayed on a growing number of different platforms. Each platform and channel now connect with each other. Besides, front-end frameworks (React, Vue, Angular, etc.) are the cause and the result of this new trend. To avoid duplication, developers manage and make content available to each platform. A CMS accomplishes this by a centralized "source of truth". This, referred to as an "API", is what each platform connects to.

> This new wave of CMS removed the visible part: they became Headless. 

<div style="width:100%;height:0;padding-bottom:125%;position:relative;"><iframe src="https://giphy.com/embed/5biWeLbFdk54texowx" width="100%" height="100%" style="position:absolute" frameBorder="0" class="giphy-embed" allowFullScreen></iframe></div><p><a href="https://giphy.com/gifs/5biWeLbFdk54texowx">via GIPHY</a></p>

Don't worry, this process harmed no one 🙂 But a lot of companies are surfing on this wave. The large majority of them offer paid closed source, cloud-based (SaaS) solutions. These types of solutions may work for relatively straightforward applications. For many developers, an off-the-shelf admin panel and API falls short of their needs. Many requirements also include keeping the data stored on secure private servers. And if their service is down, yours is too. Well, in the end, you do not control your CMS and your content.

For these reasons (and others), open source software is a good option for companies who need to keep control of their data. We are proud to have many enterprise companies concerned about customization and data ownership among our users.

> We strongly believe the open source nature of Strapi will make it the de-facto Headless CMS.

### Promoting Strapi with no bullshit

To make it happen, we already started spreading the word. For the first time, we had speakers at the API Days in Paris, France.

> As our users are the best ambassadors of Strapi, we try to invite them each time we can, as a testimonial as well as a reward.

For this major event, we invited [Derrick Mehaffy](https://twitter.com/derrickmehaffy). Derrick is one of the most active contributors of the Strapi community. He responded to more than 600 issues and pull requests on the GitHub repository! If you joined the [public Slack](http://slack.strapi.io), I am sure he answered at least one of your questions. Thanks again Derrick, and all the other contributors, for what you do each and every day for Strapi.

![API Day Paris](/uploads/48426740_2316253611992065_8340802183612071936_n.jpg_a9e6e789db.jpeg)

### Team

The team grew: Alexandre and Yves recently joined team! Alexandre (Front-End Engineer, on the right), will develop the features you have been waiting for. Yves (Marketing and Communication manager, on the left) will help you with being even more satisfied.

> Behind every open source project, there is a community. Behind every project, there is a team.

![Team Strapi](/uploads/team-strapi.jpg_2ef3d76a67.jpeg)

We consider ourselves more as a family than a team. We love spending time together. In October, we have spent a few days in Marrakech, Marrocco. Here are some pictures of this trip!

![Strapi Marrakech](/uploads/DSC07928-copy-2.jpg_3564d90f89.jpeg)

![Strapi Marrakech](/content/images/2018/12/b30bc145-162d-4a74-9f66-444fad30dfe7.JPG)

Some other rock stars are joining the team over the next few months. Stay tuned!

Oh, by the way, we are still hiring, [join us](https://www.welcometothejungle.com/fr/companies/strapi)! 👋

## What's next? 🛣

Last year was a great year. Get ready for something even more exciting.

> Two words structure 2019: "Product" and "Community".

### Product roadmap

Strapi will really come to life when any developer will be able to develop its own plugins and share them with others. The power of Strapi lives in its plugin system and to reach this goal, we are going to release two things:

- **Buffet**, our new component library **built with React** and **Styled-Component**. Like Bootstrap, we'll offer to the community **a bunch of components** (input, button, list, tables, etc) to the community to give the power of **creating beautiful** and **well-designed** interfaces.

- A **new plugin framework** that will **let everyone to play with it to connect plugins between them** and easily **customize some parts of the dashboard**. It will also provide a new wave of built-in APIs to update the menu, the configurations and the design of your project. 

> Extensibility is the key.

Both of this piece of software will be officially released at the end of March/beginning of April.

#### From alpha to stable version

Currently, Strapi is still in alpha version. Even if it is used by **thousands of companies** in production, this flag can be alarming for business projects. Releasing a stable version is one of our highest priorities. We plan to release the **Beta version in April** and the **stable one in August**.

#### Upcoming features

Also, a lot of features are coming through the year:

 - Content Internationalization
 - Admin & Permissions
 - WYSWYG HTML Editor
 - Pages
 - Automatic project update
 - Media Library

**Take a look at the [roadmap](https://portal.productboard.com/strapi) for more details.**

#### More satisfaction

We want to you to be happy from the moment you discover Strapi to your usage in production. Everything should be super smooth.

> Making our users more satisfied is our obsession.

To make it happen, we are going to improve the onboarding process: demo, installation, guided tour, etc. The documentation will be improved to make it more straightforward. Last but not least, we will also offer many tutorials to guide you through every step and to illustrate best practices, patterns, and best practices.

Tell us in the comments what you would like!

---

Thank you to all - users, contributors, followers, ambassadors, partners - for being part of this fantastic journey!

We wish you a happy, amazing and new year! 🥰

Did we forget anything you would like for this new year? Give us some insights in the comments section.

goodbye-2018-hello-2019

Goodbye 2018, Hello 2019 🎉

Welcome on the 3th "Inside box" article.

The last month has been very intense for us! We worked hard on the framework and the hosting solution. As you may know, great news are coming for Strapi. We will soon dedicate an entire post. We can't tell you more as long as it's not done!

## About the v3
**Framework layer advancements**

We pushed a lot of work on the `master` branch. We added a **new validation layer**. We were inspired by the awesome work done on the Hapi framework. That's why, we decided to use **Joi** directly on the router. However, Strapi uses the JSON object syntax (*[see the related PR](https://github.com/strapi/strapi/pull/158)*) for an easier configuration from a UI.

Then, we **updated the dependencies** in the core and external hooks. We chose to use `koa-sslify` instead of `koa-ssl`. This middleware is more **maintained** and more **popular**. It also offers more features such as **Azure support** and **reverse proxies** (*[see the related PR](https://github.com/strapi/strapi/pull/159)*).

Finally, we merged the `feature/plugins` branch which is a big step for us (*[see the related PR](https://github.com/strapi/strapi/pull/157)*). This work provides an **alpha support for plugins**. The plugins are loaded into the core framework (dictionary, config, router). A plugin is like a sub-app with its own controllers, models, services and assets. It has its own router but it can also override routes in the main router.

**Administration panel advancements**

We delayed the release of the administration panel. We have experienced some strange bugs to load plugins. We decided to not release it until it is stable.

**Hosting platform**

In our last post, we revealed that we are working on **our own hosting solution** to allow the community **to deploy** their Strapi's apps **in seconds without any devOps' knowledge**. One of us is fully dedicated to this platform and we are making good progress on it. Some of you will be able to test the platform before its official release. The other good news is that we will provide a **free trial plan** to everyone without credit card required.

## Next steps

* Release the administration panel on GitHub
* Develop the first three plugins (Custom Content Builder, Content Manager, Settings Manager)
* Release the alpha version


---

How can I help you? Feel free to submit a PR or [open an issue](https://github.com/wistityhq/strapi/issues/new) on GitHub. Send us an email at [hi@strapi.io](mailto:hi@strapi.io), if you need support or anything else, we will be glad to chat with you. Don’t hesitate to ping us on [Slack](http://slack.strapi.io).

Thanks for reading!

Inside the box - October, 2016

**Happy New Year to all who celebrated the start of 2021 on January 1st 🎉**

The entire Strapi team wishes all the best to you, your loved ones, and actually, to the entire world, since we definitely want everything to be back to normal.

2020 has been such an unforgettable year! It has been a special one for sure. The COVID-19 pandemic has had dramatic consequences and is continuing to impact everyone and businesses all over the world. We’re looking forward to better days.

Not everything has been lost though. In fact, for Strapi, it has been the best year ever. We feel lucky and are extremely grateful for the support of our colleagues, investors, customers, partners, and the overall community of users.

Over the last 12 months, Strapi has grown:
- From Beta to [Stable](/blog/strapi-stable-community-edition) 💪
- From 300 to [600+ Contributors](https://github.com/strapi/strapi/graphs/contributors) 😳
- From 20k to [30k+ GitHub Stars](https://github.com/strapi/strapi/stargazers) ([add yours!](https://github.com/strapi/strapi/stargazers)) 🌟
- From 500k to [2M+ annual downloads](https://npm-stat.com/charts.html?package=strapi&from=2015-10-01&to=2020-12-31) 🚀
- From 12 to 25 new people in the Team (+5 that arrived in January and [we’re still hiring](https://www.welcometothejungle.com/en/companies/strapi/jobs)) 😃

![number of Strapi downloads per year graph](/uploads/Screen_Shot_2021_01_06_at_15_19_27_99182216e2.png)
 
Strapi was also recognized with a [Noonie award](https://noonies.tech/award/js-innovation-of-the-year:-special-mentions) by Hackernoon as the **JavaScript Innovation of the Year** far and away selected by voters. We appreciate the votes from the technologists of the Hackernoon community. You make us proud and we promise to do the same for you.

![JS Innovation of the Year - Special Mentions strapi-gif.gif](/uploads/JS_Innovation_of_the_Year_Special_Mentions_strapi_gif_bb77ca7bce.gif)

## 2020 in review 👀

### Community

As an open-source project, a vibrant community means everything to us. Strapi wouldn’t be the same without all your valuable feedback, contributions, and recommendations.

The [repository](https://github.com/strapi/strapi) has been super active:
- 300 new contributors
- 1277 pull-requests merged
- 11474 issues/PR comments
- 10k+ new GitHub Stars

![GitHub Activity Strapi](/uploads/Orbit_strapi_Git_Hub_Activities_by_Type_2020_01_01_2020_12_31_bcf3976250.png)

The community members published **30 articles** through the new [Write for the Community program](/write-for-the-community), contributing to a total of **115 posts on the [blog](/blog)**! The new [Strapi Awesome repository](https://github.com/strapi/awesome-strapi) contains a curated list of the most amazing resources from the Strapi community. Also, the Strapi [Community Stars](/blog/introducing-the-strapi-community-stars-program) has officially launched.

![Community stars 1](/uploads/Community_stars_1_1_9317606b16.jpg)
![Community stars 2](/uploads/Community_stars_2_1_5e6c7ecfc1.jpg)

We also announced [StrapiConf](https://www.strapi.io/strapi-conf-2021), a virtual conference that will take place on **April 22nd, 2021** and bring together all the Strapi users, contributors, customers, and partners from all over the world for a day filled with Strapi learning, collaboration, and networking opportunities. The official schedule will be published soon but you can already [pre-register](https://www.strapi.io/strapi-conf-2021) and [submit proposals](https://docs.google.com/forms/d/e/1FAIpQLScUYkXm67c-yHccRYsskeUMWO4uwoWtFsBBElmVlrFYYfUyow/viewform) today!

![Blog Cover Strapi Conf](/uploads/Blog_Cover_Strapi_Conf_2_5307d2b5ca.jpeg)

Tons of new resources are now available to make every Strapi user successful. [Jim’s recipes](https://www.youtube.com/playlist?list=PL7Q0DQYATmvhlHxHqfKHsr-zFls2mIVTi) made Strapi cooking easier for thousands of you. The documentation includes many more resources, including the new [user guide](https://strapi.io/documentation/user-docs/latest/getting-started/introduction.html) for non-technical people. Furthermore, the new [Forum](https://forum.strapi.io/) centralizes all of your questions and responses so you can find solutions faster than ever.

Last but not least, we launched Strapi Academy, a great resource for the community to learn Strapi for free and develop their Strapi expertise and make the most out of it through advanced customization and plugins!

**UPD. September 2021:** Strapi Academy was temporarily closed. Learn more in [this blog post](https://strapi.io/blog/announcing-the-end-of-the-strapi-academy).

![Strapi.Academy](/uploads/Strapi_Academy_c230fe6671.png)

**A HUGE thanks to all of you for your contributions!**

### Product

Same time last year, Strapi was in beta and is now available through a [stable production-ready version](/blog/strapi-stable-community-edition).

Many of the most requested features have been released:
- [Administrator Roles & Permissions](https://strapi.io/blog/announcing-3.1-role-based-access-control) (aka RBAC): precisely define what administrators can do.
- [Media Library](https://strapi.io/media-library): manage assets at scale.
- [Single Types](https://strapi.io/blog/beta-19-single-types-uid-field) made Strapi the most flexible Headless CMS.
- [UUID Field](https://strapi.io/blog/beta-19-single-types-uid-field): create slug or similar fields.
- [Draft & Publish](https://strapi.io/blog/announcing-a-new-draft-and-publish-feature): draft your thoughts and make it live when it is ready.
- [Templates](https://strapi.io/documentation/developer-docs/latest/setup-deployment-guides/installation/templates.html#templates): start with a use-case ready project.
- [Starters](https://strapi.io/starters): get up and running in a minute.
- [Relation fields](https://strapi.io/blog/product-updates-relational-fields-displayed-in-the-list-view): see related entries from the list view and filter as you need.

Is there any feature you haven’t tried yet? You should definitely [update your projects](https://strapi.io/documentation/developer-docs/latest/update-migration-guides/migration-guides.html#instructions) or [create a new one](https://strapi.io/documentation/developer-docs/latest/getting-started/quick-start.html):


```
npx create strapi-app my-app --quickstart
```

### Company

#### New website and branding

We completely revamped our [logo](/newsroom) and [website design](https://strapi.io/) while keeping our rocket to reach the moon and beyond.

#### Series A

We raised a [$10m Series A](https://strapi.io/blog/announcing-strapi-10m-series-a-funding) with some of the best investors who truly believe in open-source.

#### Enterprise Edition

To make Strapi both enterprise-ready and sustainable, we published the [Enterprise Edition](/enterprise) of Strapi and made the [Bronze Edition free for all students, non-profit organizations as well as open-source projects](https://strapi.io/blog/introducing-bronze-plan-new-hosted-trials-and-starter-library). 

#### Team

Like every company, the pandemic changed the way we work together. We switched from a remote-friendly to a remote-first organization. Strapiers are now in 4 different countries: the US, France, Spain, and even Zambia. By the way, [we are still hiring](https://www.welcometothejungle.com/en/companies/strapi/jobs).

Despite the difficult context, the entire team has been absolutely amazing. Congrats to all of them!

![The Strapi Team](/uploads/teampicture_compressed_1_4ee5315c29_85b4383d9c.jpg)

This list of achievements is obviously non-exhaustive. Tons of other improvements happened within these 12 months.

## 2021: What’s coming next? 🛣

From the beginning, the mission of Strapi has been to empower the community to build millions of projects.

To move forward with this vision, we defined 3 priorities for 2021:
- Product
- Community
- Ecosystem

### Product

You added thousands of upvotes to the [public roadmap](https://portal.productboard.com/strapi/1-roadmap/tabs/2-under-consideration), feedback on [GitHub](https://github.com/strapi/strapi), and comments in the [forum](http://forum.strapi.io/). 

Based on your insights, we prioritized the following items:
- [SSO](https://portal.productboard.com/strapi/1-roadmap/c/71-sso-permissions-management-via-third-parties): authenticate admin users using your favorite user management system.
- [Content Internationalization](https://portal.productboard.com/strapi/1-roadmap/c/19-content-internationalization-ce-ee-v4): translate your content in many locales.
- [API Tokens](https://portal.productboard.com/strapi/1-roadmap/c/40-api-token-with-permissions): easily secure your API, with granularity.

Our top priorities will be to improve the Developer Experience and the Content Editing Experience while structuring our community ecosystem with better integrations.

### Community

What will make the success of Strapi is not the product itself: it’s you, the Strapi community. You make Strapi successful when you talk about Strapi, when you contribute, when you share your feedback, etc.
We owe you everything and are forever grateful.

#### Transparency

We want the team and the community to move forward as a single group.

We will provide as much visibility as possible into what we're developing, so you can easily anticipate what's coming next and participate as you see fit. To do so, we will share more [RFCs](https://github.com/strapi/rfcs), release a brand new plugin API (see below), and Design System.

#### External contributions

These contributions can be in the [source code](https://github.com/strapi/strapi), the [documentation](https://github.com/strapi/documentation), but also new [articles](https://strapi.io/write-for-the-community), [events](https://strapi.io/community), etc. 

We’ll continue making things easy to give you the ability to make Strapi the project you want to be.

#### Ecosystem

Plugins are what made the most-used traditional CMSs so powerful and successful. 

Having an excellent product is great. Being able to extend and customize it through plugins is a game-changer.

Imagine all the things you will be able to do with [Custom Fields](https://portal.productboard.com/strapi/1-roadmap/c/10-custom-fields) i.e select a location, retrieve products from Shopify, synchronize your content with Elastic or Algolia, connect to your own CRM, etc.

Most of these are currently possible through customization, but the plugin system deserves its stable API.

By the end of the year, we will release an official Plugin API which will give you the possibility to install plugins and develop your own plugins with ease and confidence.

For the same reasons, we will also improve our Design System so you can build extensions while benefiting from components having the same design as the rest of the admin panel.

## Ready? 🚀

Does this sound like a great plan for you? Is there anything else you would like from Strapi? Please share your feedback in the comments.

Looking forward to the upcoming announcements? We need you. Please share this post so it will encourage both the community and the team to make Strapi the future of content management.

And again, Happy New Year! It’s gonna be another great one for the Strapi community, the perfect time to get involved!




large_Goodbye 2020, Hello 2021! (2) (1).png

medium_Goodbye 2020, Hello 2021! (2) (1).png

small_Goodbye 2020, Hello 2021! (2) (1).png

thumbnail_Goodbye 2020, Hello 2021! (2) (1).png

Goodbye 2020, Hello 2021! (2) (1).png

Strapi CEO Pierre Burgy takes a look back on 2020 and explains what's coming up in 2021. Proud of what we accomplished, but with great energy to do more in 2021! 

Goodbye 2020, Hello 2021!

Hi folks!

We have been a little quiet the last few weeks. We work hard on the new version! We made a lot of improvements and we want to share them with you.

To keep you involved about our progress on Strapi, we have thought about posting fresh news every two/three weeks on GitHub or on our blog. This is a way for us to keep you informed about what we are doing. Some of you told us that they can not see any activity on the project because we posted some news only on our Slack channel. We had heard you. That’s why we made the decision to post news on a regular basis.

## v2.0 alpha release 
As you certainly know, during the last months, we worked a lot of a brand new version of Strapi. The purpose was to move from Waterline to Bookshelf, change the repository structure, improve the GraphQL and JSON API implementations and make some performance improvements. However, we decided to move on (more details in our last blog post https://strapi.io/blog/the-future-of-strapi). The consequences were that this new version doesn’t fit with our future needs anymore.

Some of you had started their projects on the v2.0-alpha, that’s why we released it very discreetly to put your project in production. We will be following up with the people concerned about this version. However, please do not start your project on the v2.0-alpha, use the v1.5.4.

## About the v3.0 

In our new vision, we defined three main words: community, flexibility, simplicity. Which means Strapi will be very easy-to-setup and easy-to-use. Everything will be a plugin. You will be able to custom your project to perfectly fit with your needs. No more useless and unnecessary feature. And finally, a single marketplace for sharing plugins into the community.

To reach our goal, we had to make some changes in Strapi. Firstly, our framework layer had to be reworked a bit, and we need to build a brand new administration panel to embrace the plugins.

**Framework layer advancements:**

* Using ES6 syntax in the whole codebase. We will still use require() while import/export are not natively supported by Node.js.
* Separating hooks by categories. We divided the hooks into four parts (core, dictionary, models, web sockets). Each part is fully independent. This allows us to encapsulate bugs. For example, if the web sockets server crashes, the core (HTTP server) will not be impacted.
* Rewriting of few parts to simplify and reduce the codebase and improve performances.
* Supporting new property nextTo in the package.json hook to provide the ability to load a hook after another one. For example, Bookshelf needs to be loaded after Knex. This will be useful for the of the plugins load.
* Supporting Mongoose ORM by default. You will still be able to use Bookshelf instead. However, the whole ecosystem (plugins) will have to use Mongoose. Why Mongoose? MongoDB is the most popular NoSQL database. It works pretty well with Node.js. It is efficient and it is very easy-to-setup. Moreover, it is more easy-to-use than SQL database (no migration, schemaless). Our main priority is to avoid frictions and build a dead simple ecosystem.
* Removing GraphQL and JSONAPI from the core framework. ***The both functionalities will be plugins***.

**Administration panel advancements**

* Setting up the architecture. Our stack will be very basic: React, Redux, Webpack, and Bootstrap (custom).
* Starting design of the administration panel.

[![Administration Panel](/uploads/201603-OSX10-ChromeBrowser-preview.png_4209c8a4c9.png)](https://blog.strapi.io/uploads/Strapi-Admin-ChromeBrowser.png_32fd7f9d02.png)

**Plugins advancements**

* Setting up the architecture. A plugin is like a sub-app. It is a React component with a backend MVC layer. A plugin will be able to:
 * Interact with the backend server (routes, dictionary, hooks, etc).
 * Interact with the administration panel

*Why can’t I see anything on GitHub?*

Currently, we are working on a private repository. Our work had been dirty and instable to have time to find the right way to make what we described above possible. The framework layer will be pushed on the new branch called v3.0 within the next two weeks.

![We are so excited about this brand new version](/uploads/giphy--1--1.gif_4d174ca126.gif)

## Community 
We want to thank everyone for your support! More and more of you joined the community during the last weeks. We are now more than 300 on our public Slack channel and we reached one thousand of downloads on npm during the last month. We hope these numbers will continue to increase over the next months. This would be awesome!

## Next steps 
For the next weeks, our main goals are :

* Developing the structure of the administration panel
* Starting the migration of the Studio’s features into plugins (API manager, Settings manager, Databases manager, etc.)


How can I help you? Feel free to submit a PR or [open an issue](https://github.com/wistityhq/strapi/issues/new) on GitHub. Send us an email at [hi@strapi.io](mailto:hi@strapi.io), if you need support or anything else, we will be glad to chat with you. Don’t hesitate to ping us on [Slack](https://slack.strapi.io) (@jim, @aureliengeorget, @pierreburgy).



Thanks for reading!

inside-the-box-july-2016

Inside the box - July, 2016

Welcome on the 4th "Inside box" article ✌️

This month was dedicated to the **prerelease of the alpha** version. We wished that we could deliver more but we have to deal with others things which tend to slow us. Despite this, **we made good improvements** and we can't wait to talk about them!

## About the v3
**Framework layer advancements**

The **framework** is now able to **support the dashboard**. This is a big step for the project and we are pretty excited about that. Currently, the dashboard is pretty empty, and you can't do anything with it (*[see the related PR](https://github.com/strapi/strapi/pull/168)*) but it can **handle plugins**, what is quite useful. 

----------
We are developing the first plugins, right now. We faced an important choice. We decided to **have separated states stores** for the plugins and the dashboard. This choice is not definitive and it could be revoked during the next weeks.

At this time, our **main arguments** are:

* Don't let a plugin access to others plugins stores (security issue)
* Simplify the development process of a plugin
* Have a standalone dashboard which only registers plugins

*Don't hesitate to give your opinion about that!* We would be very happy to talk about this choice to make the best decision for the project. You must be aware that having separate stores could increase the difficulty to share data (aka states) between plugins...

----------

We also did few enhancements to **simplify the contributions on Strapi** (*[see the related PR](https://github.com/strapi/strapi/pull/169)*). This is very important for us. Before, it was very complicated to help us because the workflow was not well designed. We didn't give any solution to easily install a development version of Strapi. This is all gone. **By running a single command** `npm run setup` or `yarn setup`, you're ready to contribute! 🎉

To do that, and for the future, we decided to use [Lerna](https://lernajs.io) to manage our mono-repository as [Babel](https://github.com/babel/babel), [Jest](https://github.com/facebook/jest) and many others already do (*[see the related PR](https://github.com/strapi/strapi/pull/170)*). If you don't know this project, you should definitely take a look!

**Administration panel advancements**

We released the **very first version of the dashboard**. We recognise that it's a little weird to release something that is empty and not ready yet. Our philosophy is **to show to the community our progress** on the new version. This was one of our previous mistakes, that's why we prefer merging on the `master` branch our WIP instead of working on a hidden branch.


## Next steps

* Fix a random and recurrent Webpack's issue during the dashboard build.
* Develop the first three plugins  (Custom Content Builder, Content Manager, Settings Manager).


---

How can I help you? Feel free to submit a PR or [open an issue](https://github.com/wistityhq/strapi/issues/new) on GitHub. Send us an email at [hi@strapi.io](mailto:hi@strapi.io), if you need support or anything else, we will be glad to chat with you. Don’t hesitate to ping us on [Slack](http://slack.strapi.io).

Thanks for reading!

Inside the box - November, 2016

We are very excited to announce that we published our first Coffee Talk, a Q&A session video with Aurélien Georget, Strapi CPO.

The community has been asking questions on social media and on our slack and we felt that they would like to know a bit more about the people behind Strapi. This is how we came up with the idea of the Coffee Talks. We thought we would do our own one but with a little spin on it. 

This idea is to reply to all the questions you ask us, one Strapi member at the time. Because some of you are wondering which directions Strapi is going, we thought Aurélien Georget, that is leading the vision, would be the first to be interviewed. 

So here is the video and you can find below the transcript of the questions he answered for you.

[![Strapi Coffee Talk #1 with Aurelien CPO](https://img.youtube.com/vi/bfXi0ehOePg/0.jpg)](https://www.youtube.com/watch?v=bfXi0ehOePg)

**How old are you, can you describe your background and how you came up with this idea?**

I'm 25, I started coding when I was 13-14, at the beginning just as a hobby and my first project was to build a CMS, a game CMS for one of my customers and I never left the world of CMS since then.

**What is your role within Strapi?**

As a CPO, my main goal is to lead the vision, I'm getting a lot of insight from the community, from our productboard. I try to align them with our vision, and with our roadmap even if sometimes it's a little bit tricky to do it, but we try to accept all the insights we have.

**How do you make long term decision regarding the framework?**

The developer experience is the most important thing for us. We know exactly how Strapi should look like in 2 or 3 years. So we are trying to build a product as developers because we are developers. And sometimes we prefer to promote the user experience over the right way to do it as a developer. I think Strapi has a great balance between both. We have a pretty good developer experience but also the user experience in the administration panel is very important, and I think that's one of the thing that is making a difference right now.

**How often do you stumble over existing parts that need reworking that do not fit in your todays vision of Strapi?**

Very often. Because right now, I'm pretty sure you know it, but we are currently rewriting the administration panel and all the plugin framework. There is a lot of parts of the code base that did not change since the beginning of Strapi. I think  we have pretty solid bases, but we can do far better and we can improve a lot the codebase and specific parts of the projects.

**Is the vision clear? Is it becoming clearer every day?**

Yes, the vision is clear and it's becoming clearer everyday. As an example, the roadmap is defined for the next 12 months and more. The main issue we are facing it the lack of human resources and contributors in the project. We have a lot of feature to make and we are looking for people and we are hiring so you can apply on our website, if your want.

**What are some of your current short term and long term plans with regards to the Strapi roadmap?**

The next big challenges we have is to rebuild all the plugin framework we have. We plan to have a new hook system to let plugins connect together and have better interactions together.
The next feature we are going to release is the repeatable fields. It's one of the missing features, it's asked a lot by the community. We have a lot of feedback and insight on it so thank you again.
The next feature after is the translation plugin. A lot of people wants to translate their content in several languages, so this is the next plugin. This plugin won't be free but I'll talk about it later.

**Why @strapijs over @storyblok?**

So for this video, when I saw your question on twitter, I tested Storyblok again. They have a visual approach which is great, I think, for building websites. But as a headless CMS, when you want to build a mobile app, or if you want to connect your API with connected objects, I think this approach can be limited. 
Also, Storyblok is a cloud based solution, so you cannot customise the administration panel, you cannot customise the API, you don't know where the data is stored, you don't know the owner of your data.
Whereas when you are using Strapi, you own everything. You own your data, you own your code, you own your API, you can customise everything, so that's why I believe in the Strapi approach but yeah, it's a great product, but it's not the same, they are cloud-based and we are open-source.

**Given your work done on the graphQL plugin, do you feel it is better/worse than REST or do you feel both should be used?**

Great question. I think both approaches are great. GraphQL is a super technology and REST as well. I really do love GraphQL, but both approaches are great and you can use what you want.

**Windows support? 😁**

You should use a Mac (haha). Yes, we have to admit we weren't perfect on Windows but we focused a lot of our efforts improving Windows support during the last month, so you should go check it out and I hope you will like it. 

**Would you mind sharing some business cases that uses Strapi? That would be really cool to have some great integration best practice. Thanks**

Yeah, we have a lot of big companies which are currently using Strapi. If you go on our website, you can see that we have IBM, we also have Asos, Discovery Channel and a lot more that we cannot share with you. 
You can use Strapi to build a mobile application, you can use Strapi with Gastby to build a frontend website, you can use Strapi to build a connected object or whatever you want. If you want to share content on any kind of devices and platform, Strapi is the product to do it.

**What are your thoughts on getting Strapi profitable?**

As you might know, Strapi is an open-source project. It's free and will always stay free. But this summer, we plan to release for example, the translation plugin and this plugin won't be free, you will have to pay to use it. So this is our main business model. We also plan to do support and even hosting in the long term. So, yeah, that's the main points of our business model.

**Will you offer a SaaS version of Strapi with 3 environments in the future, like Directus?**

Yeah, it could happen. Not in the near future, but yeah, it might happen in more than 2 or 3 years, sure. 

**Are you single?**

Yes, I am single. (laughs) What is that?? (clap) This is the end.

Thanks everyone for watching this video. Please leave a comment below and subscribe to our YouTube channel. If you have any questions, please ask us on twitter, Slack or Github, and see you soon bye.

Here are the questions that also have been asked on twitter:

**Will Strapi come up with a framework for creating large-scale API solutions, competing with express, mongo or other powerful languages to create APIs?**

Strapi is currently based on top of Koa. We don’t plan to create our own framework for now. I cannot see any advantages by doing it. It scales pretty well and Koa does the job 👍

**When are you planning to release Strapi 3 Stable? You are already in alpha for a very long time...**

We made the choice to stay in alpha for a very long time for many reasons. The #1 is that the architecture is going to change, and we know it since the beginning. Then, it allows us to make breaking changes, even if we try to avoid them as much as possible. Building an ecosystem like we are doing is not easy and we want to take our time to make the best choices. However, releasing the stable version is one of our main goal this year! The beta is planned at the end of April and the stable version should be available in August.








Coffee Talk #1 with Aurélien Georget, Strapi CPO

coffee-talk-1-aurelien-georget

 [If you haven't yet, register now for StrapiConf!](https://conf.strapi.io)

A few weeks ago, we [announced](https://strapi.io/blog/save-the-date-strapi-conf-2022) our second global user conference, StrapiConf, which will be taking place on **March 16 and 17, 2022**.  

Today, we are happy to launch the StrapiConf website along with a little surprise as part of the  registration process. After registering, you can use your Github account to generate your conference ticket (Don't worry if you don't have a Github account, your registration is already confirmed without one). 

Each StrapiConf ticket holds a "Strapi Fragment" and there are 4 different categories. Here's what each category means:


* Legendary 🏆  a PR with more than 50 commits 
* Community 💜 a PR made by community members 
* Epic 🔥 a PR with 50 codes added or deleted 
* Rare 💥 a PR that make things happen

![Capture_decran_2022-01-18_a_14.44.25_69.png](/uploads/Capture_decran_2022_01_18_a_14_44_25_69_03b3d583fe.png)

Discover what your ticket holds and share your Strapi fragment using the #StrapiConf hashtag! 

**Sponsors**

We are excited to announce our first batch of sponsors for StrapiConf 2022.

Big thank you to [Gatsby](https://www.gatsbyjs.com), [Medusa Commerce](https://www.medusajs.com), [Couchbase](https://www.couchbase.com), [Netlify](https://www.netlify.com), [Render](https://render.com), [Ionic](https://ionic.io), [Mux](https://mux.com), [PassionatePeople](http://passionatepeople.io), and [MediaJams](http://mediajams.dev) for their contribution to this event and sharing how you can use their products together with Strapi. 

![Capture_decran_2022-01-18_a_09.34.37_69.png](/uploads/Capture_decran_2022_01_18_a_09_34_37_69_9afabae732.png)

Interested in Sponsoring StrapiConf 2022? Please email us at conf@strapi.io

**CFP: Speak at StrapiConf**

We have already received many submissions with very interesting topics. And we look forward to having more talks being submitted as we approach the extended deadline in two days, January 20, 2022.

Last chance,[ submit your StrapiConf talk](https://docs.google.com/forms/d/e/1FAIpQLSfj2clqy7udvebnJl5IwTsvnnW8R1Cq89X8hfRESo5_OMvTCA/viewform?_hsmi=200712689&_hsenc=p2ANqtz--u45srMrnoCzFprDhRywQ6IYw3Hu9JXJnYVHWYTA49G6TQzWvonjHcwFPRnHXrLcxbI49ipPeNolwMN7PtvYQ-26jHKAa) now!

**StrapiConf Hackathon**

As may have noticed, the theme of the conference is building faster, together. The StrapiConf hackathon is a unique opportunity to come together and build plugins that add value to the Strapi ecosystem. In addition to awesome prizes and benefits, the hackathon winner(s) will get the chance to share what they create at StrapiConf! 

Follow[ @strapijs](https://twitter.com/strapijs) for updates on the schedule and some very exciting speaker announcements.


medium_Capture_decran_2022-01-18_a_14.44.04_67.png

small_Capture_decran_2022-01-18_a_14.44.04_67.png

thumbnail_Capture_decran_2022-01-18_a_14.44.04_67.png

Capture_decran_2022-01-18_a_14.44.04_67.png

In this blog post, our CEO [Pierre Burgy](https://twitter.com/pierre_burgy) answers frequently asked questions about [Strapi](https://strapi.io/), the project, the company, and its business model.

Don’t hesitate to ask additional questions in the comments if this blog post does not include the answers you were looking for.


### How big is Strapi and where are you based out of?

The company is based in the heart of Paris, France and has over **13 full-time employees** with one fully remote employee based in San Francisco, California. 
Strapi recently [announced]((https://techcrunch.com/2019/10/15/headless-cms-company-strapi-raises-4-million/)) a $4M seed round led by Accel and stride.vc with the participation of Notable angel investors and open-source experts such as **Solomon Hykes** (Founder of Docker), **Guillermo Rauch** (Founder of Next.js and [Zeit.co](https://zeit.co/)) and **Eli Collins** (Ex-CTO at Cloudera). 

The funding is being used to **scale the team**, get the product to a stable version including the most requested features from the community and lay the foundation for a sustainable monetization strategy. 

![](/uploads/teampicwithvictor.jpeg_2f1076fdee.jpeg)


### Why should companies care about Strapi?

With more than 700K downloads, [20K stars](https://github.com/strapi/strapi) and 300 individuals contributors, Strapi is the most flexible [open-source Headless Content Management System (CMS)](https://strapi.io/overview). It gives developers **the freedom to use their favorite tools and frameworks** while helping editors to **easily manage their content and distribute anywhere**. 

By making the admin panel and API easily customizable and extensible through a plugin system, Strapi enables the **world’s largest companies** to accelerate content delivery while building better digital experiences.


### Is Strapi 100% Open Source?

Yes. Strapi is published under a **standard MIT license**. All contributions made to the project via GitHub pull requests are governed by the MIT license. The Open Source third-party components used by Strapi are also governed by licenses that are **compatible with the vast majority of standard Open Source licenses**. 

In addition to the main Strapi project, we have also open-sourced a **component library** called [Buffet.js](https://buffetjs.io/) to help the community build plugins and better user experiences in application interfaces.

Our team is composed of open source enthusiasts who firmly believe in **transparency and value community contributions and inputs**. 



### How do you plan to build a sustainable business if Strapi is Open Source?
 
Strapi is and will **always be open-source and free**. That being said, we’re currently looking at different business models including a SaaS offering hosted by Strapi and a Self-Managed Enterprise version for customers who would like to host their own instances on-premises or in the cloud.

Our enterprise version will include features that are specifically tied to enterprise use-cases such as internationalization, Single Sign-On, Role-Based Access Control, etc. 


### How can one get involved and collaborate with the Strapi community?

Whether you have a technical background or not, we aim to make every community member **feel welcome** and provide **useful information** so that all stakeholders can get the most out of Strapi.

Today, our learning resources and communication channels ([documentation](https://strapi.io/documentation/3.0.0-beta.x/getting-started/quick-start.html), [forum](https://spectrum.chat/strapi), [tutorials](https://strapi.io/tutorials)) are mostly online and directed to **developers**. In the future, we do plan to bring the community together offline (meetups, workshops, office-hours) and offer a greater breadth of resources for less technical profiles such as **content editors** who need to learn how to use the administration panel.

### What’s Strapi tech stack?

Internally, we use the following frameworks and programming languages to build, deploy and manage Strapi. 

![](/uploads/Screen-Shot-2020-01-14-at-12.23.06.png_9784eb4ec1.png)

We also use [ProductBoard](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration) to build our public roadmap based on user feature requests, [GitHub](https://github.com/strapi/strapi) as our source code and product management software, TravisCI as our continuous Integration system and [Sentry](https://sentry.io/) for software monitoring. If you like our tech stack and are looking for a new professional challenge, check out our [job openings](https://www.welcometothejungle.com/fr/companies/strapi/jobs). 
 
### How is Strapi different from traditional CMS such as Wordpress?

Traditional CMS such as Wordpress or Drupal are monolithic systems that include the backend UI, plugins, front-end templates, CSS, a web server and database. They tend to be slower, heavier and require a lot of custom development to become responsive to various display devices. In recent years, traditional CMSs have evolved to overcome these challenges and are often calling themselves **Headless** although **most of them are in fact Decoupled**.

According to Dean Barker, the author of the Web Content Management Book, the difference between Decoupled and Headless is the following:

>A decoupled CMS is proactive — it prepares content for presentation and pushes it into a delivery environment. A headless CMS is reactive — it manages content, then just sits and waits for some process to ask for it.

As a headless CMS, Strapi provides **backend functionalities** for websites and apps built with the **[JAMstack](https://strapi.io/blog/jamstack)** (JavaScript, APIs, and prerendered Markup, served without web servers). **Strapi supports most databases**, both **REST and graphQL API** and is designed to work with the most popular front-end frameworks including **[Gatsby](https://strapi.io/blog/building-a-static-website-using-gatsby-and-strapi), [Nuxt](https://strapi.io/blog/build-a-blog-using-nuxt-strapi-and-apollo), [Next.js](https://strapi.io/blog/strapi-next-setup/)** or another static site generator. Our main objective is to become **the most flexible and extensible headless CMS on the market**. 

![](/uploads/Screen-Shot-2020-01-15-at-10.16.52.png_f379814c85.png)

### Who are your competitors?
 
[HeadlessCMS.org](https://headlesscms.org) does a great job of presenting and comparing the different players in the market based on CMS types, support for SSGs and licenses. 

![](/uploads/Screen-Shot-2020-01-14-at-12.30.20.png_2ffce22e4e.png)

The main differentiators are **self-hosted Open Source** vs SaaS and API-driven vs git-based. 

![](/uploads/Screen-Shot-2020-01-15-at-10.17.42.png_d8aeba980a.png)


### What are the most popular Strapi uses cases?

Thousands of companies and enterprises such as **[Societe Generale](https://strapi.io/stories/societe-generale-develops-e-training-website-with-strapi)**, **[IBM](https://www.ibm.com/thought-leadership/institute-business-value)**, **Discovery Channel**, and **[ASOS](https://www.collusion.com/)** are already using Strapi to build and manage their **blogs**,  **editorial**, **corporate** or **catalog** websites and **mobile applications**. 

We’ve also found some more original use cases such as [Shelt.in](https://strapi.io/stories/shelt-in-uses-strapi-to-deliver-firefighters-vital-key-data) who uses Strapi to manage their content delivery to **portable IoT devices** ensuring the safety of firefighters.

![](/uploads/Screen-Shot-2020-01-15-at-10.19.05.png_245bd08b20.png)

### What is the profile/size of company that can benefit the most from Strapi?

Companies who are fighting traditional CMS technical debt, ongoing maintenance, unreliable performance and spending a lot of time making their content responsive to an ever-increasing number of devices and channels, would benefit from using Strapi.
Companies experiencing these pain points are usually mid-size companies or enterprises in the **Retail, Media, Banking or Software industry** who realize static sites are safer, faster and more cost-effective. 

##### Learn more about Strapi:

[Get Started with Strapi](https://strapi.io/documentation/3.0.0-beta.x/getting-started/quick-start.html)

[Read the Strapi blog](https://strapi.io/blog)

<iframe width="100%" height="360" frameborder="0" src="https://app.livestorm.co/p/01e3640f-ba96-4c6a-82c4-118ee3be967a/form"></iframe>

[Follow Strapi tutorials](https://strapi.io/tutorials)




top-10-questions-to-strapi-ceo

medium_Snipcart Strapi.png

small_Snipcart Strapi.png

thumbnail_Snipcart Strapi.png

Snipcart Strapi.png

Migrating our community chat from Slack to Discord

![Happy New Year](/uploads/New-Year---2019-1.jpg_70b4b1268c.jpeg)

First of all, Happy New Year!

<blockquote class="twitter-tweet"><p lang="en" dir="ltr">*knock knock knock*<br>- Who&#39;s this?<br>- Strapi.<br>- Strapi who?<br>- Strapi New Year 🎉 <br><br>The Strapi team wishes you a joyful, healthy and happy new year 2020 🚀</p>&mdash; Strapi (@strapijs) <a href="https://twitter.com/strapijs/status/1212656987160399873?ref_src=twsrc%5Etfw">January 2, 2020</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

2019 has been another great year not only for Strapi but also for the ecosystem. 

> JAMstack and Headless CMS trends are growing like never before!

[![JAMstack and Headless CMS trends](/uploads/Screen-Shot-2020-01-08-at-11.42.12.png_0c0a0a5e62.png)](https://trends.google.com/trends/explore?date=all&q=headless%20cms,jamstack)

Over the last 12 months, Strapi grew:

 - from alpha 17 to **[beta 18](https://github.com/strapi/strapi/releases)** 🏗
 - from 15,000 to **[57,000 downloads](https://npm-stat.com/charts.html?package=strapi&from=2016-01-03&to=2020-01-03) per month** 💻
 - from 10,000 to **[20,000 stars on GitHub](https://star-history.t9t.io/#strapi/strapi)** 🌟 ([give yours!](https://github.com/strapi/strapi))
 - from 173 to **325 [contributors](https://github.com/strapi/strapi/graphs/contributors)** 🙌
 - from 6 to **12 people on the team** 👨‍👩‍👧‍👦

The numbers speak for themselves. 2019 was super exciting and made Strapi the most advanced **open-source, Node.js based, headless CMS**!

Let’s start with a quick recap of the past year.

## 2019 achievements 👀

### Community

The community has been very engaged and more vibrant than ever: 

 - 1387 issues closed
 - 726 pull requests merged
 - 168 contributors

![Strapi activity on GitHub](/uploads/Screenshot-2020-01-08-at-12.07.43-PM.png_61d0d99949.png)

A HUGE thanks and shout out to all contributors!

### Product

From the beginning, the **product has been our #1 priority**. We strongly believe that the best way to make you happy is to give you the **most wanted features** through a **fantastic user experience**. That’s why we spend so much time discussing on [GitHub issues](https://github.com/strapi/strapi/issues) and analyzing your requests on our [roadmap](https://portal.productboard.com/strapi/).

#### Features

Lots of new functionalities have been released:

 - [SQLite support & Settings view](https://strapi.io/blog/release-3-0-0-alpha-24)
 - [Admin Users split](https://strapi.io/blog/why-we-split-the-management-of-the-admin-users-and-end-users)
 - [Creating a Strapi project is way easier](https://strapi.io/blog/the-new-way-to-generate-a-strapi-application)
 - [Repeatable Groups](https://strapi.io/blog/repeatable-groups-feature)
 - [Dynamic Zones](https://strapi.io/blog/release-beta-18-dynamic-zones)
 - Tons of improvements.

Adding Repeatable Groups and Dynamic Zones made Strapi not only the leading open-source Headless CMS but also the most flexible one! Thanks to these features, you can configure Strapi to make it perfectly suited for your most specific needs required by your personal and professional projects.

#### Beta

Strapi went from [Alpha to Beta](https://strapi.io/blog/strapi-beta-is-out).

<blockquote class="twitter-tweet"><p lang="en" dir="ltr">
🎉 Goodbye alpha, hello beta!  🎉 Discover the new Strapi.

- 🆙 Seamless version upgrade
- 💅 Overhaul of the Admin UI build process
- 💪 Reliable Deployment
- 🤹‍ Improved stability
- 🎁 New Core API
- 🛤 Easier Monorepo setup

Check it out 👉 http://bit.ly/2Mrm4oQ <a href="https://twitter.com/EnnaimYassine/status/1136287885861277696">June 5, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

#### Buffet.js

We not only released features in the product but also published **an entire React components library** based on [styled-components](https://www.styled-components.com/): [Buffet.js](https://buffetjs.io/). 

That way, you will be able to quickly [create your own Strapi plugins](https://strapi.io/documentation/3.0.0-beta.x/plugin-development/quick-start.html) with a seamless design.

### Tutorials

Many of you appreciated our tutorials, like [Building a Static Blog using Gatsby and Strapi](https://strapi.io/blog/building-a-static-website-using-gatsby-and-strapi), and asked for more. For these reasons, we published the [Tutorials page](https://strapi.io/tutorials), which is both a curation of external tutorials and a way to publish **more tutorials made by the community**.

Almost 10 tutorials have been published since its publication and much more curated from the community. We are always looking for new writers. If you have already written a Strapi tutorial or blogs and would like us to feature it on our website and social media, please don't hesitate to [send us the link via email](https://strapi.io/contact) or create an issue on the [Strapi tutorial GitHub repository](https://github.com/strapi/strapi-tutorials).

### Fundraising

Headless is clearly the future of CMS and Strapi has the ambition to become the de-facto solution. To accelerate our growth we've [raised $4M](https://strapi.io/blog/announcing-strapi-4m-seed-funding-round) from awesome investors.

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**, entirely free for developers.

### Team

I am extremely proud of the team that actually **doubled in size this year**. We have been very happy to welcome Virginie, Alexandre, Maxime, Maeva, Bayane, Victor, and Julien. It’s all about people!

![Strapi team](/content/images/2020/01/IMG_2081.JPG)

Oh, by the way, [we are still hiring](https://www.welcometothejungle.com/en/companies/strapi/jobs)!

## 2020 🛣

2019 was great, 2020 is going to be even more exciting! Here are our New Year's resolutions!

### Stable version

Even though the beta version is a lot more stable than the Alpha, we know that some of you are eagerly waiting for the stable release to use Strapi in production. I'm thrilled to announce that the stable version will be released in the first quarter 🎉. 

### Product roadmap

Our public [roadmap](https://portal.productboard.com/strapi) is based on the most upvoted requests from the Strapi community.

Here are the upcoming features for the first quarter:

 - [Webhooks](https://portal.productboard.com/strapi/1-public-roadmap/c/27-webhooks)
 - [Single Types](https://portal.productboard.com/strapi/1-public-roadmap/c/9-static-content-types-pages)
 - [UID type](https://portal.productboard.com/strapi/1-public-roadmap/c/29-uid-type-seo-friendly-url) (SEO-friendly URL)
 - [Media Library](https://portal.productboard.com/strapi/1-public-roadmap/c/28-media-library-with-edit-crop-resize-capabilities)
 - [API tokens](https://portal.productboard.com/strapi/1-public-roadmap/c/40-api-access-token-with-permissions)

Then, we will release the two most wanted enterprise features:

 - [Administrators Roles & Permissions](https://portal.productboard.com/strapi/1-public-roadmap/c/8-administrators-roles-permissions)
 - [Content Internationalization](https://portal.productboard.com/strapi/1-public-roadmap/c/19-content-internationalization)

### Documentation

When it comes to advanced usage or customization, the documentation is extremely important for developers. We've added [20 guides](https://strapi.io/documentation/3.0.0-beta.x/guides/update-version.html) over the past three months. Not only will we continue in this direction but also update its structure so that you can easily find what you are looking for.

That's precisely why we are [looking for a Technical Writer](https://www.welcometothejungle.com/en/companies/strapi/jobs/technical-documentation-writer-developer-advocate_world).

### Webinars

One of our new year resolutions is to organize more Strapi events both online and offline to interact live with the community. This is why we are launching the first-ever Strapi webinar **Thursday, January 23rd 2020 - 5:00 PM (CET)**, powered by our friends at [Livestorm](https://livestorm.co/)!

Join us for this online meetup with Aurélien Georget, co-founder and Chief Product Officer as he presents what's new in the latest version of Strapi and gives us a sneak peek at what the future will look like:

<iframe width="100%" height="380" frameborder="0" src="https://app.livestorm.co/p/01e3640f-ba96-4c6a-82c4-118ee3be967a/form" title="Strapi: What's new and what's next? | Strapi"></iframe>


### Deploy

Deploying Strapi can be tricky for front-end developers who are used to LowCode/NoCode. To make your life easier we will provide you with "one-click buttons" so that you can effortlessly deploy fresh Strapi projects on your favorite cloud provider.

### Branding

Just teasing, the Strapi website will soon wear a brand new style!

---

2019 was great. 2020 is going to be awesome. We're thrilled and humbled to share this journey with you! 😀

Happy with this news? Please spread the word or add a comment. 📣

Did we forget anything in our New Year's resolutions? Please let us know and thank you so much for all these support messages throughout the year! 🚀

<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Strapi is an open source Headless CMS that looks very interesting. <a href="https://t.co/hDoFhswxob">https://t.co/hDoFhswxob</a></p>&mdash; Sid Sijbrandij (@sytses) <a href="https://twitter.com/sytses/status/1103736860335996928?ref_src=twsrc%5Etfw">March 7, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Today I have fallen in love. Head over heels. Who for? <a href="https://twitter.com/strapijs?ref_src=twsrc%5Etfw">@strapijs</a> of course 😍What a fantastic system!</p>&mdash; Gareth Thompson 🇬🇧 (@cssgareth) <a href="https://twitter.com/cssgareth/status/1082763390077059075?ref_src=twsrc%5Etfw">January 8, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

<blockquote class="twitter-tweet"><p lang="en" dir="ltr">wow... <a href="https://twitter.com/strapijs?ref_src=twsrc%5Etfw">@strapijs</a> is possibly the headless CMS I have been dreaming of all these years... within an hour I already have auth / permissions &amp; relations. It&#39;s like Wordpress ACF on steroids without PHP headache.</p>&mdash; Tom Warham (@TommWarham) <a href="https://twitter.com/TommWarham/status/1160978923590696960?ref_src=twsrc%5Etfw">August 12, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Wauw, <a href="https://twitter.com/strapijs?ref_src=twsrc%5Etfw">@strapijs</a> you are my new best friend 😍<a href="https://twitter.com/hashtag/javascript?src=hash&amp;ref_src=twsrc%5Etfw">#javascript</a> <a href="https://twitter.com/hashtag/NodeJS?src=hash&amp;ref_src=twsrc%5Etfw">#NodeJS</a> <a href="https://twitter.com/hashtag/strapijs?src=hash&amp;ref_src=twsrc%5Etfw">#strapijs</a></p>&mdash; Daniel Malmros (@dmalmros) <a href="https://twitter.com/dmalmros/status/1160285702258601989?ref_src=twsrc%5Etfw">August 10, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

<blockquote class="twitter-tweet"><p lang="en" dir="ltr">*finds out about <a href="https://twitter.com/strapijs?ref_src=twsrc%5Etfw">@strapijs</a>*<br><br>*then finds out how easy it is to implement GraphQL on strapi*<br><br>Wait....that&#39;s it? That&#39;s all you have to do? <a href="https://t.co/EpYzMbmZno">pic.twitter.com/EpYzMbmZno</a></p>&mdash; Glen Codes (@GlenCodes) <a href="https://twitter.com/GlenCodes/status/1208028770466070528?ref_src=twsrc%5Etfw">December 20, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>







2019-year-in-review

Goodbye 2019, Hello 2020

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

Get Started

Today, we’re thrilled to announce our partnership with Cloudflare through the Cloudflare Deploy Hooks for Strapi. 

We’re excited about this partnership with Cloudflare because it enables developers to abstract away the complexity of deploying changes to production for content teams. By using the Deploy Hook for Strapi, everyone can push new content and updates quickly and autonomously. 

Knowing that the Jamstack architecture is gaining momentum together with Headless CMS like Strapi, Cloudflare [announced Pages support for Deploy Hooks](https://blog.cloudflare.com/introducing-deploy-hooks-for-cloudflare-pages/) back in August 2021. 

The Deploy Hook for Strapi allows you to connect and trigger deployments in Pages via updates made in your Strapi project. In other words, it means that you can easily configure Strapi webhooks to trigger deployments on events like autosave, manual save, and publish. Once the specified event happens, you can find a new deployment being triggered in the Pages dashboard automatically. That’s it. Content teams no longer need to rely on developers to push new changes to production.
Get started 

To learn more about how you can connect your Strapi project to Cloudflare Pages, check out the [Deploy Hooks documentation.](https://developers.cloudflare.com/pages/platform/deploy-hooks) 



medium_Strapi & Next Corporate Starter-3.png

small_Strapi & Next Corporate Starter-3.png

thumbnail_Strapi & Next Corporate Starter-3.png

Strapi & Next Corporate Starter-3.png

If you are using a static website generator (or framework with build option) with Strapi (Gatsby, Nuxt, Next, etc.) it is necessary to rebuild it when the content is updated in Strapi. In a Headless CMS, this is typically called a Webhook feature. Unfortunately it is not available yet in Strapi even if [it has been requested](https://portal.productboard.com/strapi/c/27-webhooks).

But what we like at Strapi is to help developers. So even if the feature is not developed yet, this short article gives you an easy way to implement work around! 😃

![Webhooks](/uploads/webhooks.png_16a00f833c.png)

### Discovering the lifecycle callbacks 🔍

As you may know, every Content Type (aka models) has lifecycle callbacks: functions which are triggered every time an entry is fetched, inserted, updated or deleted. Here is the list:

 - Callbacks on `save` (both triggered on entry creation and update): `beforeSave`, `afterSave`.
 - Callbacks on `fetch`: `beforeFetch`, `afterFetch`.
 - Callbacks on `fetchAll`: `beforeFetchAll`, `afterFetchAll`.
 - Callbacks on `create`: `beforeCreate`, `afterCreate`.
 - Callbacks on `update`: `beforeUpdate`, `afterUpdate`.
 - Callbacks on `destroy`: `beforeDestroy`, `afterDestroy`.

All of these functions are available in a file located at `api/yourContentType/models/YourContentType.js`.

If your goal is to rebuild a static website, the only useful callbacks are `afterCreate`, `afterUpdate` and `afterDestroy`. So, uncomment them, add logs and try to create, update and delete entries from the admin panel.

*Path: `api/yourContentType/models/YourContentType.js`*

<script src="https://gist.github.com/strapi-codesnipets/f2654ee4d9a939be9ba7c2fbe7e24de7.js"></script>

### Making the HTTP call 🔊

We are almost there: the only thing we still need to do is to actually make the HTTP call to the URL which will rebuild the static website.

#### URL config

So first of all, let's store this URL in a proper way. To do so, edit `config/environments/development/custom.json`:

*Path: `config/environments/development/custom.json`*

```json
{
  "staticWebsiteBuildURL": "https://yourservice.com/"
}
```

Do the same thing for other environments.

#### HTTP call

Now it is time to make the HTTP call. In this example we will use `axios` as it is already in the list of Strapi's dependencies. Let's install it:

```
npm i axios --save
```

Edit `api/yourContentType/models/YourContentType.js`:

*Path: `api/yourContentType/models/YourContentType.js`*

<script src="https://gist.github.com/strapi-codesnipets/da45f8be5b7cbcb515e7bcd5ebea1ed7.js"></script>

#### Mongoose limitation

Until September 2018, `remove` lifecycle callback [was not supported by Mongoose](https://github.com/Automattic/mongoose/issues/3054). This has been added but `strapi-hook-mongoose` is not adapted yet to this update.

So, to trigger an url on delete, please add `request.post(strapi.config.currentEnvironment.staticWebsiteBuildURL, entry);` in:

 - `remove` action of `api/yourContentType/services/YourContentType.js` (triggered by your public API).
 - `delete` action of `plugins/content-manager/services/ContentManager.js` (triggered by the Content Manager).

*Note: do not forget to require `request` at the top of these files.*

### Conclusion

Articles of this type are made to help you. We hope they do! Please comment with your suggestions.

Need more help? Ask your questions on [StackOverflow](https://stackoverflow.com/questions/tagged/strapi), submit issues on [GitHub](https://github.com/strapi/strapi/issues) and request features on [ProductBoard](https://portal.productboard.com/strapi)!

Adding Webhooks in Strapi 🎯

**Webhooks** is a term you might have heard before in other apps, and you might have been hooked on it (pun intended 😉), wondering what it is about. We are very excited to announce that the **Webhooks feature is now available** in the latest version of Strapi released today!
The full changelog can be found in the repository [here](https://github.com/strapi/strapi/releases/tag/v3.0.0-beta.18.5).

We’d like to give a special shout out to [@MatWrz](https://github.com/MatWrz), [@pataiadam](https://github.com/pataiadam), [@nurikabe](https://github.com/nurikabe) and [@adcar](https://github.com/adcar) for their contributions in this release. Great job!

Webhooks are a simple way for your different applications to **communicate** and **get notified** when a new event happens.
For example, webhooks are used when you receive notifications from your tweets on Slack or when you receive SMS notifications from your banking application.

In the [headless CMS](https://strapi.io/blog/10-reasons-headless-cms) world, webhooks are very useful to build your frontend upon modification in your administration panel. But there are plenty of other useful scenarios, we'll talk about them in a second.

Let's break it down and see how it works in Strapi!


## What are webhooks?

Webhooks are **automated messages** that are sent each time an event happens. They have one unique mission: transmitting a message or data to a unique address or URL.

Think of your email inbox. In the ancient times, you had to connect to your inbox to check if you had new emails. 
Nowadays, your new emails come **directly to you through push notifications**. Checking your emails is much easier. You receive *an automated message* as soon as you receive a new email. *Boom.* 

Well, webhooks are the same but between apps. 

#### Technically, how do they work?


Webhooks use **HTTP POST requests**. When an event is triggered, a first app sends an **HTTP POST payload** to the URL of a second app configured in the webhook. 

The most straightforward way HTTP requests work is **by appending data** to a URL and ping that URL. The URL looks like this, with data following a question mark in the URL: 

    https://yourapp.com/data/12345?Author=John&title=my_article&content=lorem_ipsum

Then, your app will receive the information that something new happened, and do what it has to do. 

To make it simpler, it's like **a command-line with data, sent from an app to another over HTTP.**

The data sent will look like this: 

    {
      "event": "entry.create",
      "created_at": "2020-01-10T08:47:36.649Z",
      "model": "address",
      "entry": {
        "id": 1,
        "geolocation": {},
        "city": "Paris",
        "postal_code": null,
        "category": null,
        "full_name": "Paris",
        "created_at": "2020-01-10T08:47:36.264Z",
        "updated_at": "2020-01-10T08:47:36.264Z",
        "cover": null,
        "images": []
      }
    }

#### So are Webhooks the same as APIs?

There are many ways applications interface with data. **Webhooks** are just one of them. **APIs (Application Programming Interfaces)** are similar but different at the same time and useful for their specific usages.

The main difference is in the fact that webhooks are **automatic**: you set up them once, and then they run with any manual action. APIs require to manually request data and are very useful when you know you'll have constant changes in your data.

To use an example, you could see an API like getting a meal you ordered from the waiter at the restaurant. A webhook would be more like your waiter throwing you a pizza every time they pass by.

Let's see how it works in Strapi.

## How to use webhooks in Strapi?

In this example, we are going to create a webhook to automatically deploy a modification on [Netlify](https://www.netlify.com/).

#### 1. Creating a webhook

So, first, let's create a new webhook.

![Creating a new webhook](/uploads/Screen-Shot-2020-01-20-at-14.49.41.png_6657ea26e2.png)

Your webhook needs to call an URL, in this case, the Netlify API, and needs to contain special headers that describe what the event is.

![Webhook Header](/uploads/Screen-Shot-2020-01-20-at-14.59.57.png_86faa3c98c.png)

Depending on the kind of events, they can have multiple headers. The *Hooks* section shows which object of ***created*, *edited* and *deleted* ids** should be included in the delivered payload.

![Multiple headers](/uploads/Screen-Shot-2020-01-20-at-14.59.18.png_109968ca05.png)

#### 2. Testing the webhook

After creation, you need to test-trigger your newly created webhook. To do so, Strapi provides a **Trigger button**, allowing to see if your webhook is fully functional.

![](/uploads/Screen-Shot-2020-01-20-at-15.36.34.png_da4771b5fd.png)

#### 3. Enabling or disabling webhooks

You can easily create as many webhooks as you need, the only limit is your imagination. Webhooks can be used to **send emails** when a page is updated, to **trigger a website build**, to **notify a messaging app** upon modification or any other scenarios you could think of.

The Strapi UI allows you to easily **enable or disable** any webhook created.

![](/uploads/Screen-Shot-2020-01-20-at-15.49.02.png_7ed3c1ce04.png)

## Other features

This release also features:

- an upgrade to purest 3.x from [@thomb](https://github.com/thomb),
- a new [guide](https://strapi.io/documentation/3.0.0-beta.x/guides/scheduled-publication.html#introduction) explaining how to plan the publication of an article using CRON functions,
- new [scheduling parameters to SendGrid Provider](https://github.com/strapi/strapi/pull/5017),
- a new guide explaining [how to create a slug system](https://strapi.io/documentation/3.0.0-beta.x/guides/slug.html) for a Post, Article or any Content Type you want,

and much more!

Check the changelog [here](https://github.com/strapi/strapi/releases/tag/v3.0.0-beta.18.5).


## Let's get started!

If you are new to Strapi, just give it a try!

Take a look at the [Getting Started](https://strapi.io/documentation/3.0.0-beta.x/getting-started/quick-start.html#_1-install-strapi-globally) guide to jump on board, or get started with the following command line:

    yarn create strapi-app my-app --quickstart


#### Get involved

Check out our public product roadmap to see what features we’ll be working on next.

Don’t see a feature you’d like in the backlog? Feel free to [submit new feature requests](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration) or even better, **[start contributing](https://github.com/strapi/strapi/blob/master/CONTRIBUTING.md)** to Strapi on GitHub. All contributions and users are welcome!

Webhooks explained and how to use them in Strapi

## Introduction

Strapi is a self-hosted, fully-customizable, headless CMS that uses Javascript in its operations. Hooks are one of the main built-in developer interfaces that we can use to customize and extend Strapi's default functionality.

In this article, we'll review and compare the three different types of Strapi hooks - describing and summarizing each type's method of implementation and common use cases.

To follow this article, although not required, a basic familiarity with Strapi will help to understand the use cases and code snippets. Nevertheless, this is not a step-by-step guide, so feel free to skim through or go directly to the hooks section you're looking for.


## Goal

At the end of this article, you should understand the different types and categories of hooks in Strapi.


## Prerequisites

You'll need a basic understanding of the following to proceed.


- Basic knowledge of JavaScript for Node.js
- Basic understanding of Strapi - [get started here](https://strapi.io/documentation/developer-docs/latest/getting-started/introduction.html).
- Downloaded and installed latest [Node.js](https://nodejs.org/en/) v14.

## **Content-Type Hooks**

If you're familiar with Strapi, you most likely already know what a Content-Type (or Model) is. A Content-Type is a JSON representation used to specify the underlying database structure of a content entity we want to store in Strapi's database.

The first type of hooks we'll examine are [lifecycle hooks](https://docs.strapi.io/developer-docs/latest/development/backend-customization/models.html#available-lifecycle-events). These hooks allow us to extend Strapi's default **Content-Type** functionality by introducing custom code that will run whenever (before or after) a [query](https://docs.strapi.io/developer-docs/latest/developer-resources/database-apis-reference/query-engine/bulk-operations.html#updatemany) is executed over a Content-Type. It would work regardless of how it's done, whether through the Admin Panel, an API call, or the execution of custom code that uses **default** queries.


> "When you are building custom ORM-specific queries the lifecycles will not be triggered. You can, however, call a lifecycle function directly if you wish." - [Strapi Developer Documentation](https://docs.strapi.io/developer-docs/latest/development/backend-customization/models.html#model-creation)

**Use Case Examples**
Lifecycle hooks are ideal for when you want to automatically trigger an action whenever Strapi content is queried or updated. For instance, lifecycle hooks can be used in an e-commerce app to send an email notification or clear a CDN cache when a new product is added to the store.

**How to Implement a Content-Type Hook**
To create a Content-Type lifecycle hook, first, you'll have to determine to which **model** and to which **query** you would like to attach the hook. Here's the list of the available default Strapi queries:


- `create`: Creates an entry in the database and returns the entry.
- `createMany`: Creates multiple entries in the database returns the entry.
- `update`: Updates an entry in the database and returns the entry.
- `updateMany`: Update multuple entries in the database and returns the entry.
- `delete`: Deletes an entry (or multiple entries at once) and return its value.
- `deleteMany`: Deletes multiple entries at once and returns it value.
- `count`: Returns the count of entries matching Strapi filters.
- `findOne`: Returns the first entry matching some basic parameters.
- `findMany`: Returns multiple entries matching some basic parameters 

For each of the previous events, you can configure the hook to run before or after the event is executed. To do so, capitalize the first letter of the event name and prefix it with `before` or `after`.
You can now set a `lifecycles` key in the model file `./api/[api-name]/content-types/[content-type-name]/{modelName}.js` with its respective lifecycle hooks. Going back to the previous e-commerce app example, this is how a **Product** lifecycle hook that sends an email notification every time a new product is created could look like:

```js
    module.exports = {
      lifecycles: {
         afterCreate(event) {
          const { result, params  } = event;
          await strapi.plugins["email"].services.email.send({
            to: "customers@my-store.io",
            from: "noreply@my-store.io",
            subject: "New Product Available!",
            text: "Check out this amazing new product :)",
          });
        },
      },
    };
```


## **Server Hooks**

The second type of hooks, server hooks, allows us to add functionality to Strapi's core. When the Strapi instance boots, server hooks are loaded into the global object, becoming therefore usable anywhere in the application.

**Use Case Examples**
By far, the most common application of server hooks is third-party service/API integration.
Check out some of the hooks made available by the community:

- [strapi-hook-algolia](https://www.npmjs.com/package/strapi-hook-algolia): This hook allows you to use [Algolia](https://algolia.com/) as a service in Strapi `strapi.services.algolia`.
- [strapi-hook-magento](https://www.npmjs.com/package/strapi-hook-magento): This hook allows you to use the [Magento 2 Rest API](https://devdocs.magento.com/guides/v2.4/rest/bk-rest.html) with Strapi.
- [strapi-hook-twitter](https://www.npmjs.com/package/strapi-hook-twitter): This hook allows you to use the [Twitter API](https://developer.twitter.com/en/docs/twitter-api) with Strapi.
- [strapi-hook-allegro](https://www.npmjs.com/package/strapi-hook-allegro): This hook allows you to use [Allegro Rest API](https://developer.allegro.pl/documentation/) with Strapi


> The above-mentioned server hooks provide a detailed guide.

A common development pattern of a server hook is to have it run an initialization function when the server boots, and then expose its functionality via methods made available either in `[strapi.services](https://docs.strapi.io/developer-docs/latest/development/backend-customization.html#api-reference)` or `[strapi.hook](https://docs.strapi.io/developer-docs/latest/development/backend-customization.html#api-reference)`.

As a result of being available in the Strapi global object, a server hook may also, for instance, be combined with a lifecycle hook, allowing for even further custom functionality.

**How to Implement a Server Hook**
The code of a server hook goes inside a file named `index.js` and should follow the structure below:

```js
    module.exports = strapi => {
      const hook = {
        /**
         * Default options
         */
        defaults: {
          // config object
        },
    
        /**
         * Initialize the hook
         */
        async initialize() {
          // Merge defaults and config/hook.json
          const settings = {...this.defaults, ...strapi.config.hook.settings.**};
    
          // await someAsyncCode()
        },
      };
    
      return hook;
    };
```

A server hook can be loaded either from a **node module** or from the **local hooks folder** (`./hooks`) in the project. Every folder that follows the pattern `strapi-hook-*` and is located in the `./node_modules` folder will be mounted into the `strapi.hook` object.

Every folder that is inside the `./hooks` folder will also be seen as a hook and mounted in the `strapi.hook` object. Regardless of the location from where it is loaded, for a hook to run at the instance boot, it needs to be enabled and configured in your Strapi app.

The `./config/hook.js` file is where we enable the hook, alongside any optional custom settings:

```js
    module.exports = {
      settings: {
        'hook-name': {
          enabled: true,
           applicationId: 'ABCDEFGHIJ',
            apiKey: 'secure api_key',
            debug: true,              // default: false
            prefix: 'my_own_prefix',   // default: Strapi environment (stra          pi.config.environment)
        },
      },
    };
```

Let's now examine the implementation specificity of each server hook location.

**Node Module Hook**

The node module approach is useful if you'd like to publish the hook as an [npm](https://www.npmjs.com/) package so that it can be easily shared across multiple projects and make use of all the features npm provides. A node module hook requires the following folder structure:


    /strapi-hook-[...]
    └─── lib
         - index.js
    - LICENSE.md
    - package.json
    - README.md

The `index.js` file is the entry point to the hook. It has to follow the structure of the `index.js` example above.

**Local Hook**

A local hook is a server hook that is imported directly from the `./hooks` folder at the root of your project, without having to be installed through npm. It's useful for project-specific hooks that won't be reused in other Strapi projects.

To add a local hook to your project, create a folder with the name of the hook and a `index.js` file inside it:


    /project
    └─── admin
    └─── api
    └─── config
    │    - hook.js
    └─── hooks
    │   └─── strapi-my-local-hook
    │        - index.js
    └─── public
    - favicon.ico
    - package.json
    - server.js


## Webhooks

The last type of hooks is [webhooks](https://docs.strapi.io/developer-docs/latest/development/backend-customization/webhooks.html).


> Sunny Hsiao wrote an [article specifically about webhooks](https://strapi.io/blog/what-is-a-webhook-and-how-does-it-work), going more in-depth than I will in this general overview, so I recommend you check it out if you'd like to dive deeper into webhooks.

Webhooks are not exclusive to Strapi; an application that implements webhooks is able to notify other applications as a certain event occurs in its context. Technically, webhooks are typically implemented as HTTP POST requests.

**Use Case Examples**
A webhook can be a great tool to notify third-party providers to run CI/CD operations, such as build or deploy. Recently, I came across an interesting use case in this [Strapi webinar by Charles Ouellet, where a webhook is used to rebuild a Nuxt static site whenever the content is updated in Strapi.](https://www.youtube.com/watch?v=u9pg5fuKI9s)

**How to Configure a Webhook**
The webhook configuration panel is accessible from the Admin Panel, from the sidebar, in **Settings** -> **Webhooks**. 
To create a new webhook, click the **“****Add new webhook**” button in the top-right side of the panel:


![Adding a New Webhook](https://paper-attachments.dropbox.com/s_31312C6150B19DE32C6CFC091D43039299F53C6E4193643238CD6AF763026F6D_1644703192745_webH.PNG)



Next, you'll need to fill in the **Create a webhook** form with the following fields and click  save in thesame top-right side of the panel:

- Name
- URL
- Request headers
- Trigger events


![Creating a Webhook](https://paper-attachments.dropbox.com/s_31312C6150B19DE32C6CFC091D43039299F53C6E4193643238CD6AF763026F6D_1645320645747_web5.PNG)


By default, Strapi provides a set of events that can trigger a webhook. These events are related to either a **Content-Type entry** or a **media asset**.

For Content-Type entries, we have the following events available:

- `create`: When an entry is created.
- `update`: When an entry is updated.
- `delete`: When an entry is deleted.
- `publish`: When an entry is published (available when [draft and publish](https://docs.strapi.io/developer-docs/latest/concepts/draft-and-publish.html) is enabled on the Content-Type).
- `unpublish`: When an entry is unpublished (available when draft and publish is enabled on the Content-Type).

For media assets:

- `create`: When a media asset is created.
- `update`: When a media asset is updated.
- `delete`: When a media asset is deleted.

Here's how a sample webhook payload looks like:


    {
      "event": "entry.create",
      "created_at": "2020-01-10T08:47:36.649Z",
      "model": "address",
      "entry": {
        "id": 1,
        "geolocation": {},
        "city": "Paris",
        "postal_code": null,
        "category": null,
        "full_name": "Paris",
        "created_at": "2020-01-10T08:47:36.264Z",
        "updated_at": "2020-01-10T08:47:36.264Z",
        "cover": null,
        "images": []
      }
    }
     

You can also set additional webhook global header configurations. This is done in the `./config/server.js` file and will be applied to all the outgoing webhooks.

```js
    module.exports = {
      webhooks: {
        defaultHeaders: {
          'Custom-Header': 'my-custom-header',
        },
      },
    };
```

If it's an Authorization header, you can use `Authorization: 'Bearer my-very-secured-token',` instead. This will allow the notified applications to read the header and appropriately handle verification and authentication.

Besides the explicitly configured headers, Strapi will also add another header named `X-Strapi-Event`, where the corresponding value is the name of the event type that was triggered.


## Conclusion

As we've seen, hooks are a great tool for customizing and extending Strapi's core functionality. We've examined the three different types of Strapi hooks, presenting the main use cases for each type, when to use one or another, and how to implement them.

This tutorial was updated with Strapi v4.

Understanding the different types/categories of Strapi Hooks

Today, I'm announcing that we are going to temporarily close the [Strapi Academy](https://academy.strapi.io/) on September 30th, 2021.

The Academy was created a bit over a year ago to provide Strapi clients some special content to help them get the most out of Strapi and follow best practices when implementing it. We then opened the platform to share the content with everyone. We also used it for the Partner program to guarantee that you have quality partners working on your projects. But today, it is time to temporarily close it.

Today, the Academy represents more than 6,000 students. It helped many community members and clients improve their Strapi skills and helped them build upon their understanding of how Strapi works. Making the configuration, customization, and usage much easier.

## But why are we closing the Strapi Academy?

Well, first of all, the current courses will become obsolete with the release of the v4. So all the content in the Academy would have to be rebuilt from scratch. Many technical concepts will change, and the UX/UI has been improved thanks to the [new Strapi design system](https://github.com/strapi/parts).

We worked really hard last year to create the current courses. We did our best with the team to keep the content up to date. But it's a lot of work to maintain it all when all Strapi efforts are directed towards improving the project and creating new features. That means that almost every 2-3 months, when we launch something new, the content would have to be updated.

Creating the same courses with the same or better quality for the v4 is currently not possible with our team's size. This would require a lot of effort, and the current team is not large enough to support this project.

For now, the priority of the User Success department, which is in charge of the Academy, is mainly centered around building the Customer Success team to support our growing customer base, the Support team to help community members and clients by handling their technical questions, and Documentation to provide you the best documentation possible for you to easily learn Strapi and achieve your project goals.

## So what now?

We're going to keep working on existing resources for the release of the v4!

You can find the [Resource Center](https://strapi.io/resource-center) that regroups all resources to learn and improve your Strapi skills.

The [Strapi Documentation](https://strapi.io/documentation/), Developer documentation, and User Guides are there to help you understand the interface and technical concepts of Strapi. All of the Academy's content is, in fact, already present in the Documentation.

The current courses will not disappear. We migrated all video content to a [YouTube playlist here](https://youtube.com/playlist?list=PL7Q0DQYATmvgzPF8WVaf0nDtar3zDiXgY). With that, you will still be able to access the content.

Depending on your preferred support, you can still find [written tutorials](https://strapi.io/tutorials) or [video tutorials](https://strapi.io/video-library).

Threat not, we will continue to create new resources for you to make your Strapi project a success.

Regarding the partner program, Academy certifications will no longer be a requirement for companies to become an official partner. Instead, any company interested in [becoming a partner](https://strapi.io/partner-program#contact) will now have to complete a quiz that will test their technical and business knowledge of Strapi.

The goal here remains the same: making sure that agencies that we recommend to our users are fully aware of Strapi's features and capabilities, but also that they are following our best practices with their implementation of the solution.

## What are our plans for the future?

We know that providing resources for you to learn and succeed with Strapi is essential.

That's the reason why we hope to create a Learning/Education team next year, and this team will be dedicated to managing this important project.

 **The Academy will be back.**

medium_Monthly Updates.png

small_Monthly Updates.png

thumbnail_Monthly Updates.png

Monthly Updates.png

 Announcing the End of the Strapi Academy

Free_EE_for_Student_Open_source...

Today is a big milestone for Strapi. We’re introducing a public beta version of [Strapi Enterprise Edition (EE)](https://github.com/strapi/strapi) along with paid plans including enterprise differentiating features and support services. We’re developing [Strapi Enterprise Edition](https://strapi.io/enterprise) in the open, in collaboration with partners and customers, and remain fully committed to delivering value to the Strapi open-source community and ecosystem.

In this blog post, I try to reflect on what this announcement means for Strapi: the company, the product, and the open-source project. 

## The Company

With Jim and Aurelien (other Strapi cofounders), we’re all big Open Source enthusiasts. That’s why, from day one, we released [Strapi on GitHub](https://github.com/strapi/strapi) under a permissive MIT license which is, in our opinion, the only way to build and maintain a truly meaningful piece of software. 

To truly compete in a mature and fragmented CMS industry, we invested a lot of time and effort into research and development without making any revenue. Raising capital from famous business angels and venture capital firms was the best way to build a feature-complete Headless Content Management System (CMS) and vibrant Open Source community at the same time. 

Today, we’re making a major step towards making Strapi a sustainable, capital-efficient business or in other words, a Commercial Open-Source Software Company. Similar to companies we admire and love such as GitLab or Hashicorp, the Strapi team is building an opinionated product on top of an open-source project built together with the Strapi community.

Over time, our company vision has matured and now goes far beyond becoming the de facto standard for the A in JAMstack. At Strapi, we believe that everyone should have the power to easily build content-driven applications and modern digital experiences regardless of the end devices and channels. In other words, a key enabler of the next revolution of low-code, no-code development taking advantage of APIs.

## The Product

As explained in this [excellent article](https://coss.media/deriving-product-from-open-source/) by Joseph Jacks from OSS Capital, a packaged experience and buyer-specific features is often what differentiates commercial products from their open-source roots. 

Over the last 6 months, we have been researching our user profiles and what are the most important features for them. It turns out that many Strapi users are actually fairly large enterprises that are looking for a modern, open-source, and self-hosted Headless CMS. When we asked them what features they would be willing to pay for, the most common features requested were all related to security and governance: Role-Based Access Control (RBAC), Single Sign-On (SSO), Audit logs as documented on the [enterpriseready.io](http://www.enterpriseready.io/) website.

Based on the feedback from the [Strapi public roadmap](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration), we also knew that the RBAC feature was not only important to enterprise users but pretty much all of our users, as it is a fairly standard CMS capability. 

At that point, it became clear that this feature was the one we would develop first and that it would be available in both Strapi Community and Enterprise Editions with a different level of granularity. With the new advanced RBAC feature, enterprises have full command over the privileges a user or group of users should have to do their job. It is highly customizable, providing administrators with a high level of granularity in order to define a set of actions that users should be allowed to perform on their own for various types of content or settings. Please refer to this [blog post](/blog/announcing-3.1-role-based-access-control) for more information on the difference between the basic and advanced RBAC features and how to configure them in Strapi. 

Anyone interested in finding out more about the pricing and plans for [Strapi EE](https://strapi.io/enterprise) should go to [Pricing](https://strapi.io/pricing). Please note that there is a FAQ section at the bottom of the page that should answer all your questions. 

Fees are based on the number of projects. A project is a Strapi instance sharing the same Content Types structure and codebase. If a Strapi project is deployed in several environments or scaled on several instances on localhost or under the same domain, it is considered as only one project.

You can refer to the [Strapi public roadmap](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration) to see what features will be included in Strapi EE. 

![Slide Paid Plans](/uploads/Slide_Paid_Plans_69f532c7f8.jpeg)

## Training and Support 

The Silver plan provides customers with access to a dedicated Help Desk, as well as online training for developers and content editors. The Gold plan includes a higher level of [support](/support) with a Service Level Agreement and a dedicated Customer Success Manager to provide guidance on Strapi project architecture, deployment, and hosting, as well as identification of potential workarounds for features that may not yet be available.  

## The Open Source Community & Ecosystem

Along with the beta release of the Enterprise Edition, we are beginning the rollout of our [partner program](/partner-program) to help our rapidly growing user base to most effectively get started with Strapi while unlocking new revenue opportunities for Strapi [partners](/partners) and freelancers. 

![Strapi Partners](/uploads/Master_deck_-_June_2020_937a390bbd.jpeg)

We already have relationships with a [handful of partners](/partners) that come from around the world that help customers deploy and use Strapi in production. Their work with customers involves custom integrations, fully customized builds, migration services, and general consulting.

If you are interested in working with us or want to know more, please go to our [simple online form](/partner-program) to contact us. 

Last but definitely not least, along with this Strapi EE launch, I want to reiterate our honest commitment to the Strapi open source community. None of this would have been possible without all of your contributions on GitHub, Slack, etc and for that, we’re forever grateful. We have had a lot of discussions about our monetization strategy both internally and with many of you in the community and will always be listening to feedback both good and bad. 

We recently created a [Strapi Request for Comments (RFCs)](https://github.com/strapi/rfcs) repository to create consensus among the core team and include as much feedback as possible from the community, for these upcoming changes. This is a good first step but we know there is a lot of work left to do to improve communication and coordination amongst the Strapi community. As the next steps, we want to invest more time and effort into improving the overall project governance and open source collaboration through a forum, mailing list, and official roles for the most active contributors. Stay tuned for more information on that in the coming weeks. 

### Learn more about Strapi EE:

- Check out the [pricing page](/pricing)
- Learn more about our [Enterprise](https://strapi.io/enterprise) offer
- [Schedule a meeting](/enterprise#contact) with the Strapi team
- [Download the latest version of Strapi CE](https://strapi.io/documentation/v3.x/getting-started/installation.html)







 Introducing Strapi Enterprise Edition (beta) and Plans

Hello Strapi Community!

Today we will be launching the new [Strapi Community forum](https://forum.strapi.io/) that has been under development for the past few weeks. As a previous member of the community myself and listening to all the suggestions, it was clear we needed a central area to talk, ask questions, and discuss all about Strapi and our wonderful ecosystem. 

![image2](https://api-prod.strapi.io/uploads/image2_2a77fedfbc.png)

Initially, we wanted to try out the new [GitHub Discussions beta](https://github.blog/2020-05-06-new-from-satellite-2020-github-codespaces-github-discussions-securing-code-in-private-repositories-and-more/#discussions), however, after spending a few weeks with it we determined it didn’t quite fit the needs of the [Strapi community](https://strapi.io/community) (many of you expressed you didn’t even know it was there). And thus in parallel with that testing, we began prototyping different solutions, and after many suggestions from all of you, we decided on using [Discourse](https://www.discourse.org/).

This new forum will become **the central point of the community** (don’t worry [our Slack](https://slack.strapi.io/) will still be there, though we will be doing some cleanup). Over the next few months, we will begin migrating some of the more popular discussions started on GitHub and Slack and will begin asking users to post their questions on the forums instead. We will be playing it by ear at the start of 2021 before we decommission the GitHub Discussions entirely, and for those of you with open discussions please don’t hesitate to reach out to us to have your discussion moved over to the forum.

![image1](https://api-prod.strapi.io/uploads/image1_21ff3af7b7.png)

The community forum will provide several key benefits to both you in the community, our customers, and to us on the Strapi team. Our primary reason was to provide you with **excellent community support**, not just us from the core team but also from key members of the community that has spent the past few years helping of their own accord. We also wanted to make it easier for newcomers to find the information they are looking for, sometimes it can be difficult to search around for the answers especially when those answers aren’t in a place you can search easily. As our community Slack is using a free plan, we are only able to keep up to **10,000 messages**, after which we lose access to those messages, our hope is that we can guide everyone to our forums and thus making it easier to ask, answer, and find the information you are looking for.

We, on the core team, do want to clarify that bug reporting and feature requests will still be handled by our [GitHub Issues](https://github.com/strapi/strapi/issues) and [Product Board](https://portal.productboard.com/strapi/1-roadmap/tabs/2-under-consideration) respectively, however, the forum will be the hub for questions, discussions, showing off your project, and letting people know about your custom plugin, middleware, extension, or tweak.

As the Strapi community grows, the platforms we choose need to be able to grow with us and we certainly feel that our choice of self-hosting our own Discourse forum will fit that role perfectly. We look forward to reading your feedback and please feel free to let us know if you think we can improve our implementation.

Learn more About Strapi:

- Request a [Hosted Strapi demo](https://strapi.io/demo)
- Sign up for the [Strapi Weekly Newsletter](https://strapi.io/email-updates)
- Check out the latest How To videos on the [Strapi Youtube Channel](https://www.youtube.com/strapi)

Introducing Strapi Community Forum

You might be also interested in 

## 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>


strapicover

Strapi closes $10 M series A Funding

We hope that you enjoyed your well-deserved holidays as we did but it’s time to get back to work!

We are excited to get even closer to our community with the **release of our very new votepage**

### The floor is yours

Over the last months, a lot happened with the Strapi V3 release. 

So not only we decided to take a step back to appreciate the progress
made and every we accomplished (the open source community and the team), but also we acknowledge that **the help and feedback of every Strapi users played a major role**.
 
As we value your contribution a lot and want to **keep your satisfaction as our main objective**, we needed to let you have a real impact on Strapi development. We still have a long road ahead of us and it was important for us to make you part of this amazing project. 

### Voice your opinion!

That is how we came up with the idea to **let you vote for the feature you would like** to be developed next with just a few clicks. This will help us know how we can better respond to your needs and **prioritize accordingly to our future development areas**.

### Give it a try!

Visit the page, login with GitHub and upvote your most wanted features.

[![Strapi Vote Page](/uploads/Screen-Shot-2018-01-11-at-10.47.13.png_41bac4ffab.png)]

As always, if you have any idea to complete this list, feel free to reach out to us and we’ll be glad to add it to the roadmap!

Be part of Strapi’s future

When we hear about Strapi, we have many things to say about what the open-source product stands for and the community that contributes to it. But behind it, there is a multicultural organization filled with talented and kind people, all gathered around the same [mission and vision](https://handbook.strapi.io/purpose-vision-mission). We have so many anecdotes to tell, the role each Strapier plays (this is how we affectionately call our teammates at Strapi that have completed the onboarding process), and what it is like to be part of building the rocket while flying it. Today, I am grateful for them, the Strapiers - who help Strapi be a better place to work every day. That is why we are thrilled to announce the new blog section: "Strapi Life Blog."

**What drives us to share about the Strapi Life?**

[Strapi's story](https://handbook.strapi.io/strapi-story) started in France as an open-source project with the three founders in 2015. Since then, Strapi has gone through three fundraisings. It went from being an office-based company to a worldwide remote-first organization. It started with three people who built Strapi as a side project, to a team of 60+ Strapiers located across seven countries.

This week, we released [Strapi v4 stable](https://strapi.io/v4), [StrapiConf 2022 is coming](https://strapi.io/blog/save-the-date-strapi-conf-2022), and this is just the beginning. The team thrives with an ambitious mindset; we are a growing company becoming more into a diverse group of people building the foundation of one of the best headless CMSs.

While this is happening in everyone's eyes, other achievements that may not be so evident are happening simultaneously, such as how we are evolving and maturing as an organization. Almost all the teams have at least duplicated the number of Strapiers, as is the case of [User Success](https://handbook.strapi.io/user-success-manual), [Marketing](https://handbook.strapi.io/marketing-manual), Engineering, [People](https://handbook.strapi.io/people-manual), and [Product](https://handbook.strapi.io/product-manual). We started 2021 with 25 Strapiers, and soon we will be 55 in total with over 13 nationalities. All these people are in different places worldwide: Zambia, Lebanon, Lithuania, Spain, Germany, France, La Réunion, and the United States. Evolving from an office-based to a remote-first organization opened the door to diversify the talent behind the product we build every day. This change has been an opportunity but as well as a big challenge.

At the same time, we launched programs, policies, and events that are becoming the core of the company culture at Strapi. Some of the major programs implemented this year were mental health for all through [Moka Care](https://www.moka.care/), a [learning and development policy](https://handbook.strapi.io/people-manual/learning-and-development-policy), parental leave mission, global company training, career path, and management; the first [Virtual Retreat](https://www.linkedin.com/feed/update/urn:li:share:6809172903272288257/), a [new career page](https://strapi.io/careers), the [Strapi Handbook](https://handbook.strapi.io/), and more. 

We share our achievements as a team, learnings, as well as the unavoidable mistakes that are part of the journey. We are growing a diverse team representative of the users we serve. We are committed to building a safe workplace where everyone feels empowered to bring their authentic selves. It is a unique experience, bonding with your teammates remotely and at the same time aligning ourselves to the same mission that is to empower the community to build millions of tailor-made projects.

**What can you expect from this blog?**

The challenge behind building Strapi's company culture remotely gave us the retrospective of the value that lies in sharing all the learnings and challenges we have faced along this path. At the same time, sharing Strapier's perspectives about their role at Strapi, their strengths, experiences, and challenges they face day-to-day. This may be useful to other people building a company, deciding on a career path, or a potential candidate applying to Strapi (find the open positions in our [career page](https://strapi.io/careers)). 

As true believers of open-source, aligned to [Strapi's value](https://handbook.strapi.io/strapi-values) transparency, this is another step we are taking to make more accessible to the Strapi Community, Partners, other companies, and candidates on how we are building Strapi as a company. If you want to see a specific topic in the Strapi Life blog, feel free to leave your suggestion in the comments section.

large_StrapiLifeBlog.png

medium_StrapiLifeBlog.png

small_StrapiLifeBlog.png

thumbnail_StrapiLifeBlog.png

StrapiLifeBlog.png


It's been quite the year for the Strapi Community. With big feature releases and a major version jump to v4, you trusted the Strapi blog as your source of truth for all things Strapi. This year we published more than 170 blog posts with more than half of those coming from you, our [Community](https://strapi.io/write-for-the-community). In this article, we&#39;ll look at some of the most-read blog posts from 2021. It was great to see what resonates with the Strapi Community as a lot of these blog posts speak to what you like the most about Strapi. So there might just be a bit of extra insight at the end.

 Let&#39;s go!

#### [**Build a blog with Next (React.js) and Strapi**](https://strapi.io/blog/build-a-blog-with-next-react-js-strapi)
In this article, Maxime talks us through how to build a blog website using Strapi for the backend and [Next.js](https://strapi.io/integrations/nextjs-cms) for the frontend.
<br>
#### [**How to change the WYSIWYG in Strapi**](https://strapi.io/blog/how-to-change-the-wysiwyg-in-strapi)
In this article, we answer a very popular question in the Strapi Community &quot; **How do we change the current WYSIWYG?&quot;**
<br>
#### [**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. Thank you to our community member Victor Kane for helping us launch Strapi with Docker.
<br>
#### [**User Authentication in Next.js with Strapi**](https://strapi.io/blog/user-authentication-in-next-js-with-strapi)
In this tutorial, we&#39;ll be building a [Next.js](https://strapi.io/integrations/nextjs-cms) application and authenticate that with [Strapi](https://strapi.io/) and [NextAuth](https://next-auth.js.org/). Thank you to our community member Nirmalya for sharing your knowledge.
<br>
#### [**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.
<br>
#### [**Configuring Strapi and MySQL**](https://strapi.io/blog/configuring-strapi-mysql-database)
The main focus of this article is to give you all the information you will need to set up and get started with Strapi v3 and MySQL. Thank you to our community friend Cretu Razvan for your MySQL tips
<br>
#### [**How to build a Strapi Custom Plugin**](https://strapi.io/blog/how-to-build-a-strapi-custom-plugin)
We go into how to create Plugins in Strapi v3 to extend the functionality of our Strapi applications. Thank you Anamadu Moses for showing the community how to build future custom plugins. Ready to make your own plugin in 2022?
<br>
#### [**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.
<br>
#### [**Create a food ordering app with Strapi and Next.js 1/7**](https://strapi.io/blog/nextjs-react-hooks-strapi-food-app-1)
A look at how to use [Next.js](https://strapi.io/integrations/nextjs-cms) ( **React 16.8 w/ hooks** ) to power your UI, complete with **GraphQL, Stripe, Strapi, and React Context** to develop a full-stack application complete with the powerful Strapi (Headless CMS) powering the backend. Thank you Ryan for this amazing 7 parts tutorial.
<br>
#### [**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.
<br>
<br>
As with every &quot;top something&quot; list, a few gems are usually left out. We can&#39;t let that happen. So here are a few posts that we think could be potentially useful 😉. A big thank you to the Strapiers and community members who wrote these golden nuggets to help you start the year right.

#### [**v4 Plugin Migration Guide**](https://strapi.io/blog/v4-plugin-migration-guide)
Here you will find all the steps you need to take to migrate your Strapi v3 plugin to v4 with as little friction as possible.
<br>
#### [**Strapi Relations 101**](https://strapi.io/blog/strapi-relations-101)
This post will give you key insights to make better decisions for your content modeling in Strapi.
<br>
#### [**Strapi Security Checklist**](https://strapi.io/blog/strapi-security-checklist)
This post acts as a Strapi security checklist and takes a look at certain security measures you can take to ensure a safer experience.
<br>
#### [**Handling Previews in a Headless Architecture**](https://strapi.io/blog/handling-previews-in-a-headless-architecture)
In this tutorial, you&#39;ll learn to implement a preview system when working with a headless CMS like [Strapi](https://strapi.io/) as well as a frontend in [Next.js](https://nextjs.org/) for creating content previews.
<br>
#### [**Content is Data, Data is not Content**](https://strapi.io/blog/content-is-data-data-is-not-content/adding-idyll-support-to-strapi)
In this article, we look at both content and data and see what role each has to play in a Headless CMS.
<br>
It&#39;s hard to talk about Strapi and 2021 without mentioning [Strapi v4.](https://strapi.io/v4)
<br>
We [announced Strapi v4](https://strapi.io/blog/announcing-strapi-v4) in late November and it&#39;s been quite the ride already. In 2022, we&#39;re looking to have more content on the blog on the new hip Strapi version. This is both for new and updated blog posts to help you get up to speed with the release.

 In the meantime, we have an amazing video series detailing all the new functionality v4 brings.

1. [What&#39;s new in Strapi v4: Design System](https://www.youtube.com/watch?v=cKc082C2gzY&amp;t=1s)
2. [What&#39;s new in Strapi v4: Plugin API](https://www.youtube.com/watch?v=-51iT5-eO9c)
3. [What&#39;s new in v4: Database Layer](https://www.youtube.com/watch?v=fGUxQ-v6qOQ&amp;t=1s)
4. [What&#39;s new in v4: Rest and GraphQL APIs](https://www.youtube.com/watch?v=jOSh2nogROg)
5. [What&#39;s new in v4: API Tokens](https://www.youtube.com/watch?v=1SlYKWMgeTE&amp;t=2s)
6. [What&#39;s new in v4: Error Handling](https://www.youtube.com/watch?v=LB6SFDKqeQc)

I&#39;m sure this makes for some great new year reading (or watching)!

Again, we really appreciate you all taking the time to engage with the content we put out and even going the extra step to contribute to the blog yourselves. There will be some really valuable content coming out next year and we can&#39;t wait to share that with you all.

Have a great one ❤

large_top blog post 2021(1).png

medium_top blog post 2021(1).png

small_top blog post 2021(1).png

thumbnail_top blog post 2021(1).png

medium_Introducing community starsA.png

small_Introducing community starsA.png

thumbnail_Introducing community starsA.png

Introducing community starsA.png

Due to the unfortunate events related to COVID-19, in-person community events are being put on hold for the next few months. We feel the pain of all the conference and meetup organizers who are forced to cancel their events and want to send them our support in this difficult and stressful time. 

In the meantime, we’re working with an incredible group of community leaders and contributors to not only organize Online Meetup but also create local Strapi meetup groups for when we can start gathering again! 

## Online Meetups 

We recently started hosting monthly Strapi Online meetups, **every third Thursday of the month at 9am PST**. In the 3rd edition that will take place on **Thursday, March 19th at 8 AM (PDT)**, [Derrick Mehaffy](https://strapi.io/blog/community-spotlight-derrick-mehaffy) (DevOps expert and long time Strapi contributor) and Jim Laurie (Strapi co-founder and CTO) will share everything you need to know about Strapi deployment options. 

![webinar strapi deployment cover](/uploads/Screen-Shot-2020-03-11-at-10.10.57-1.png_f177c966c0.png)

<p><iframe width="100%" height="360" frameborder="0" src="https://app.livestorm.co/p/80dc8c6d-6482-44f7-88af-12a433bdf21a/form"></iframe></p>

Here are the links to the video recording and slides from the first two editions:

- [Strapi: what’s new and what’s next](https://strapi.io/blog/strapi-online-meetup-1-recap) by Aurélien Georget
- [How to build a blog with React and Strapi](https://strapi.io/blog/strapi-online-meetup-2-recap) by Maxime Castres

Feel free to subscribe to our [Youtube channel](https://www.youtube.com/strapi) to be notified when the next video recordings are available! 

If you want to learn about specific Strapi topics and see what other community members are suggesting, you can also check out this [GitHub issue](https://github.com/strapi/strapi-meetups/issues/1) and vote for your topics of interest for upcoming editions. 


## IRL events

As you all know, meetups are a key medium to meet, share, learn from and collaborate with other members of open-source communities. As Strapi community members start to reach out and volunteer to create local Strapi user groups, we think now is the time to officially support this kind of initiative. 

#### Active Strapi meetup groups include:

- [Strapi Paris](https://www.meetup.com/Strapi-Paris) - led by the Strapi Paris team
- [Strapi San Francisco](https://www.meetup.com/strapi-san-francisco) - led by Victor Coisne
- [Strapi Brno](https://www.meetup.com/Strapi-CZ) - shout to [Ondřej Janošík](https://www.meetup.com/Strapi-CZ/members/282935323/)
- [Strapi Lagos](https://www.meetup.com/Strapi-Lagos/) - shout to [Adegbenga Agoro](https://www.meetup.com/Strapi-Lagos/members/236970085/) 
- [Strapi London](https://www.meetup.com/Strapi-London/) - led by [@lovekaizen](https://github.com/lovekaizen) and [@willibaur](https://github.com/willibaur)
- [Strapi Melbourne](https://www.meetup.com/Strapi-Melbourne) - shout out to Giang Pham
- [Strapi Sydney](https://www.meetup.com/Strapi-Sydney-Strapi-headless-CMS/) - shout out to [Rodrigo Rubio](https://www.meetup.com/fr-FR/Sydney-Strapi-headless-CMS/)
- [Strapi Toronto](https://www.meetup.com/Strapi-Toronto/) - led by [@Scott Agirs](https://www.meetup.com/Strapi-Toronto/members/185292937/) 

<iframe src="https://giphy.com/embed/l3q2SH4Cmhh8F40jS" width="480" height="326" frameBorder="0" class="giphy-embed" allowFullScreen></iframe><p> </p>

Strapi meetups bring together people who are interested in Strapi and the [JAMstack](https://www.meetup.com/Strapi-London/members/233570581/) ecosystem at large. We are very grateful for the people who dedicate time to encourage in-person knowledge sharing, collaboration, and mentorship within the Strapi and broader open source community. Our goal is to **provide resources and assistance** to everyone who wants to **bring the community together** by organizing Strapi meetups. 


## Frequently Asked Questions

Interested in getting involved? Here is the information you are probably looking for :)

#### What should I do if I’m interested in launching a Strapi User Group?

Create an issue on the [strapi-meetups](https://github.com/strapi/strapi-meetups) repository and send an email to meetup@strapi.io with the link to the issue you just created. We’ll then create the group on meetup.com (so that you don’t have to pay for the monthly fees) and add you as an organizer. 

#### What should I do if I’m interested in speaking at a Strapi meetup?

Create an issue on the [strapi-meetups](https://github.com/strapi/strapi-meetups) repository and send an email to the community leader in charge of the meetup group you want to speak at with the link to the issue you just created. 

#### How does Strapi support Community Leaders who organize Strapi meetups?

We see community leaders as **members of the Strapi family** and are committed to your success as Strapi and JAMstack community leaders. Here is a non-exhaustive list of things we can help with:

We send you **Strapi SWAG** (stickers, etc).
We **promote every Meetup** on [strapi.io](https://strapi.io/) website, the Strapi Weekly newsletter and Social Media.
We **connect you with employees or community members** interested in speaking at your meetup.
We connect you with companies interested in **hosting or sponsoring your meetup**.
We **provide unique networking and learning opportunities** to the community leaders.

If you have any questions about organizing Strapi meetups please check out the Meetup FAQ.  Feel free to create an issue on this repository if you don’t see the information you’re looking for or would like to suggest ideas or improvements. Contributions and feedback are much welcome and appreciated. 



Bringing the community together at Strapi meetups!

If you are familiar with our [blog](https://strapi.io/blog) you must have seen that we've released a series of tutorials on how to make blogs using Strapi with a lot of frontend frameworks: [Gatsby](https://strapi.io/blog/build-a-static-blog-with-gatsby-and-strapi), [React](https://strapi.io/blog/build-a-blog-with-react-strapi-and-apollo), [Next.js](https://strapi.io/blog/build-a-blog-with-next-react-js-strapi-and-apollo), [Vue.js](https://strapi.io/blog/build-a-blog-with-vue-strapi-and-apollo), [Nuxt.js](https://strapi.io/blog/build-a-blog-using-nuxt-strapi-and-apollo) or [Angular](https://strapi.io/blog/build-a-blog-with-angular-js-strapi-and-apollo).

Well this was my idea when I saw that a **large part of our users build editorial websites with Strapi**. My name is Maxime and I'm in charge of the [Write for the community](https://strapi.io/write-for-the-community) program. I'll explain in this blog post what this program consist of, why I created it and how you can join it. 

![Community content](/uploads/Frame-59--1-.png_68a088b04f.png)

I first came with the idea of a place where you'll be able to find every tutorials related to Strapi. I created a Github repository called strapi/strapi-tutorials where anyone can list an existing tutorial, request, create, improve or even translate a tutorial through issues. These tutorials are then listed on our [https://strapi.io/tutorials](https://strapi.io/tutorials) page and today, we count 50 of them.

The idea is dead simple, use Github repository to list and manage every existing tutorials and it's working great.

But we want to go further and expand this repository. What if we also want to list Strapi/JAMstack/open-source related articles and a showcase on this same repository, listing every project created with Strapi!  It would become a community hub where all the resources related to Strapi are gathered in one place, accessible by anyone, manageable by anyone.

So we decided to rename this repository [strapi/community-content](https://github.com/strapi/community-content) to include more amazing contributions from members of the Strapi Community. Let's take a closer to the tutorial and article part that are featured in this repository.

![Tutorials](/uploads/Frame-56.png_d031c5fee0.png)

As a developer, if I had to choose a technology, I'll definitely choose the one that has the most resources which will help me to get started **the easiest** and **fastest way possible**.

I always choose a tech with **a good documentation**, some **good tutorials** and **some examples** to discover what have people already built with it.

I noticed that it was also the case with friends of mine and it might be the case for you too. So I decided to create this tutorial section.

### How it works

All in a Github repository

You are completely free to create content on your own, publish it either on a well known blog website such as [Medium](https://medium.com), [Dev.to](http://dev.to/), Hackernoon, [Scotch.io](http://scotch.io/), your own blog or even [ours](https://strapi.io/blog)!

Submit it to our [official repository](https://github.com/strapi/community-content/tree/master/tutorials). Once your content added to the repository, it will then be visible on our [tutorials page](https://strapi.io/tutorials).

We have created a set of GitHub issue templates for everyone to contribute and collaborate on improving our collection of community tutorials

- [Submit a topic](https://github.com/strapi/community-content/issues/new?labels=Looking+for+author&template=submit-a-topic.md&title=%5BTOPIC%5D)
- [Submit a tutorial/article](https://github.com/strapi/community-content/issues/new?labels=In+progress&template=submit-a-resource.md&title=%5BSUBMIT%5D)
- [Update a tutorial](https://github.com/strapi/community-content/issues/new?labels=In+progress&template=update-a-tutorial.md&title=%5BUPDATE%5D)
- [Translate a resource](https://github.com/strapi/community-content/issues/new?template=translate-a-resource.md&title=%5BTRANSLATE%5D)

![Issues](/uploads/Capture-d-e-cran-2020-03-24-a--11.57.18.png_81e9528cd5.png)

For example, if you choose to make a tutorial request, you'll have this generated issue template that you'll only need to fill in.

![Issue](/uploads/Capture-d-e-cran-2020-03-24-a--11.31.34.png_f50d217e4c.png)

This way I can manage all the issues in the [repository project](https://github.com/strapi/community-content/projects/1) and give you visibility on the progress of the different issues.

![Project](/uploads/Capture-d-e-cran-2020-03-24-a--11.33.21.png_2f6847c1ef.png)

All published tutorials are automatically fetched and showcased on a dedicated tutorials page on the Strapi website!

![https://blog.strapi.io/uploads/Capture-d-e-cran-2020-03-03-a--16.50.34.png_060b0079bd.png](/uploads/Capture-d-e-cran-2020-03-03-a--16.50.34.png_83e3500521.png)

We're very grateful for all the contributions we've received so far, and make sure to actively promote all the tutorials submitted on this repository!

![README](/uploads/Capture-d-e-cran-2020-03-24-a--11.33.58.png_9fcb541a31.png)

### Topics

What should you write about?

If no existing [topics](https://github.com/strapi/community-content/issues?q=is%3Aissue+is%3Aopen+%5BTOPIC%5D+) inspires you, we are looking for certain types of content:

- Tutorials that teach how to create a real-world application from scratch using Strapi and any frontend tech
- Quick tutorials on how to deploy Strapi

### Rewards

We know how much time it takes to write a detailed and educational tutorial and for that reason we'll consider compensating contributions on a case by case basis.

- Your name/Github image on the official [Github repository](https://github.com/strapi/community-content/tree/master/tutorials)
- Goodies
- The complete Strapi course from Strapi training materials

Although we don't have a specific dollar amount for tutorial contribution, we have a dedicated budget..

### News

Recent tutorials:

- [How to install Strapi on DigitalOcean with 1-Click deploy button](https://scotch.io/tutorials/install-strapi-on-digitalocean-with-1-click) by [Chris On Code](https://scotch.io/@chris)
- [Delivering content with Strapi and Nuxt](https://blog.logrocket.com/delivering-content-with-strapi-and-nuxt/) by [Daniel Madalitso Phiri](https://dev.to/malgamves)
- [Single type and unique UID](https://www.youtube.com/watch?v=NmThIyxtZH8) by [Alessandro Valerani](https://github.com/GalloDaSballo)

Upcoming tutorials:

- [How to create a simple Strapi Plugin](https://github.com/strapi/community-content/issues/25) by [Boaz Poolman](https://github.com/boazpoolman)
- How to create a corporate website with Strapi by [Tomek Konieczny](https://twitter.com/tomekkoniec)
- [How to create an import content plugin](https://strapi.io/blog/how-to-create-an-import-content-plugin-part-1-4) Part 2 by [Pouya Miralayi](https://strapi.io/blog/community-spotlight-3-pouya-miralayi)
- How to create an e-commerce website with Strapi and Nuxt.js by Snipcart and Phoenix Agence Web

[Get started with Strapi tutorials](https://github.com/strapi/community-content/tree/master/tutorials)

![Articles](/uploads/Frame-57--2-.png_62db310e4d.png)

We're looking for writers who'd like to talk about their experience using Strapi, JAMstack, or open-source related things. Although we're mostly looking for experienced authors who have already published blog posts on websites such as [Medium](https://medium.com), [Dev.to](http://dev.to/), [Hackernoon](https://hackernoon.com), [Scotch.io](http://scotch.io/) or your personal blog, we're also supportive of people who have never published anything but interesting in a writing their first technical piece.

You will definitely pick our interest if you can write articles that go quite in-depth and include a significant number of learning nuggets. We're absolutely NOT looking for promotional pieces or marketing pitches. It's all about interesting things to tell to the community concerning everything that operates in the Strapi environment.

[Get started with Strapi articles](https://github.com/strapi/community-content/tree/master/articles)

If you want to be part of this program, I created a slack channel on our [Public Slack](https://slack.strapi.io/) called `makers`, feel free to join and talk with all the makers around Strapi.

Can't wait to see your contributions!

Write for the community

Today, we're super pleased to be sharing the fruits of something that we've been putting together for a few months. Today we're proud to announce the [Strapi Community Stars](https://strapi.io/community-stars) Program.

We're starting out with 9 Community Stars - all of whom you'll get to know more about in this article.
Being an Open Source Headless CMS, Open-Source values are deeply embedded in us and the [Strapi community](https://strapi.io/community). A community which means the world to us. From our first commits in late 2015 to our stable release in mid-2020, the community has stood firmly by us and given us the direction and contributions that have made us what we are today.

Contributions come in all shapes and sizes and the actions of the community speak to that.

**Pull Requests and Issues**

We've had community members open some major Pull Requests (PRs) and Issues on the Strapi project repo. Here are a few noteworthy examples of PRs submitted on the Strapi GitHub repository:

-   [Improve admin's initial load time](https://github.com/strapi/strapi/issues/7439)

-   [Add support for brotli compression](https://github.com/strapi/strapi/pull/8169)

-   [Implement Graphql Aggregation Feature for Bookshelf](https://github.com/strapi/strapi/pull/5605)

-   [New auth Provider 'Apple SignIn'](https://github.com/strapi/rfcs/pull/20)

**Meetups & Events**

Pre COVID, we had a nascent [Global Meetup Program](https://github.com/strapi/strapi-meetups) and an enthusiastic group of community leaders willing to help bring local user groups together. . Regardless, our friends at [Strapi Cz](https://www.meetup.com/Strapi-CZ/members/?op=leaders) have seen the pandemic through and with the help of [Ondřej Janošík](https://www.linkedin.com/in/ondrej-janosik42/) have held 2 events virtually with more to come ;) Here is a list of the groups that were recently started:

-   [Strapi San Francisco](https://www.meetup.com/strapi-san-francisco/)

-   [Strapi Paris](https://www.meetup.com/Strapi-paris)

-   [Strapi London](https://www.meetup.com/strapi-london/)

-   [Strapi Toronto](https://www.meetup.com/Strapi-Toronto/)

-   [Strapi Sydney](https://www.meetup.com/Sydney-Strapi-headless-CMS/)

-   [Strapi CZ (Brno + Prague)](https://www.meetup.com/Strapi-CZ/)

-   [Strapi Melbourne](https://www.meetup.com/strapi-melbourne)

**Forum and Slack**

We've recently moved from using GitHub Discussions to having a dedicated forum for the Strapi Community. Community members like [Mattie](https://www.linkedin.com/in/mattias-van-den-belt/) and [Marin](https://www.linkedin.com/in/marin-cn-7b74a6143/) have gone above and beyond on the forum making sure the transition was seamless. Here are some popular topics:

-   [Multi Tennant SaaS](https://forum.strapi.io/t/-/462) 

-   [Internationalization](https://forum.strapi.io/t/-/169) 

-   [Roles and permissions not showing after clear installation](https://forum.strapi.io/t/-/500)


**Articles and Tutorials**

Just over a few months after launching our [Write for the Community](https://strapi.io/write-for-the-community) Program, we've seen the Strapi community's ability to create and submit educational content skyrocket with amazing writers like Cretu Razvan, [Nirmalya Ghosh](https://www.linkedin.com/in/ghoshnirmalya/), [Ryan Belke](https://www.linkedin.com/in/ryanjbelke/) and Precious Luke. Since its launch, we've had community members put together more than 15 amazing articles. Here are a few worth looking at:

-   [Adding Idyll Support to Strapi](https://strapi.io/blog/adding-idyll-support-to-strapi)

-   [Strapi Authentication in Nuxt.js](https://strapi.io/blog/strapi-authentication-in-nuxt-js)

**Videos and Talks**

Active Strapi community members also record high-quality videos too! With channels like [Pragmatic Reviews](https://www.youtube.com/channel/UCOw-DRfCmhOBUPMe4ltZOSA), [Chris Sevilleja](https://www.youtube.com/channel/UCmXVXfidLZQkppLPaATcHag), Dr. [Shahin Rostamim](https://www.youtube.com/channel/UC3ThkhFr8PHy-97U3sEGW3Q), and [Alex the Entreprenerd](https://www.youtube.com/channel/UCMguCMq25nEqlHlr17iINNw) producing content and giving talks at meetups. You can find video content on Strapi all over the internet. Here are some examples.

-   [Strapi headless CMS for the JAMstack](https://www.youtube.com/watch?v=BJkI4xKuI6M)

-   [Build an Event App with Vue.js, Gridsome & Strapi.js](https://www.youtube.com/watch?v=vB6rmWCmANA&t=21s)

-   [Build an Inventory Management System Prototype with Strapi and React](https://www.youtube.com/watch?v=1wrwT0MXoUA)

## Program Goals

At its core, the Strapi Community Stars is an initiative to empower and enable active and resourceful Strapi community members who go out of their way to serve the community. We want to recognize them as leaders (read Stars) in their different disciplines as well as provide them with resources and opportunities to grow as professionals.

## Program Benefits

The program comes with various benefits which we believe will help us achieve these ambitious goals. Besides insights into a top open-source project and roadmap, the Community Stars will have a larger role to play in the feature development and testing of the project. We also, where applicable offer help towards becoming a Strapi contributor or even maintainer. 

What is a developer program without Swag? The Community Stars will have an **Exclusive Swag Pack**, Recognition on Strapi’s website, Twitter & Online Channels and opportunities to mentor hackathons & attend conferences for free. All steps towards recognizing them as leaders in their fields.

We want to empower the Strapi community, part of that is us giving the Community Stars resources and support in their areas of interest and we’ll offer them professional recommendations for the amazing work they put into their community activity.


**Our Founding Members** 🤩



**Catan Marin**
![Group 557](/uploads/Group_557_ed39fa41bf.png#small)
Aged 28 and born in Moldova. Catan was invited to Bucharest to work for an international fintech corporation with multiple brands. He has been working with them for more than 5 years now. He mostly does backend development (but not limited to it) and loves programming, automation, and cars.
[LinkedIn](https://www.linkedin.com/in/marin-cn-7b74a6143/) | [Twitter](https://twitter.com/sunnysonx)

**William Bautista-Romero**
![Group 560](/uploads/Group_560_0191d6c933.png#small)
William is a JavaScript enthusiast always looking for best ways to do his work more effectively, an advocate for A11Y and good practices, and a Linux nerd convinced that we can do any sort of frontend work using it. His motto is "Knowledge is power".
[LinkedIn](https://www.linkedin.com/in/willibaur/)

**Vanessa Pasque**
![Group 556](/uploads/Group_556_1990490ab6.png#small)
Vanessa is currently the Co-Founder and CTO at RiderClub.fr.  She has been an open-source addict for more than 10 years and loves to share and discuss with others about new technologies - a passion that began with her first experience at Mandriva, and continues today. They developed their business with the Strapi solution about two years ago, and continue to improve and create new components and plugins, and share many of them with the community. She has some hobbies: music, video-games, cooking, sleep... and her children (but they are not really compatible with her sleeping passion).
[LinkedIn](https://fr.linkedin.com/in/vanessapasque) | [Twitter](https://twitter.com/lithox)

**Scott Agirs**
![Group 563](/uploads/Group_563_6ca6c1232e.png#small)
For Scott, creating new products has always been his one true love. For over 5 years now these products are digital and all JavaScript. Gotta love JavaScript.
[LinkedIn](https://www.linkedin.com/in/scottagirs) | [Twitter](http://twitter.com/scottagirs)


**Jelmer Visser**
![Group 559](/uploads/Group_559_5a36be5b61.png#small)
Jelmer is a Lead developer @ Blue Flamingos & weflycheap. He enjoys Tech, music and coffee.
[LinkedIn](https://www.linkedin.com/in/visserjelmer) | [Twitter](https://twitter.com/jelmervisser)

**Rami Shashati**
![Group 561](/uploads/Group_561_d2a72eeee6.png#small)
Rami is a software engineer and technical writer from Portugal. On the tech-side, his main interests are JavaScript, Vue, Nuxt, Jamstack, software architectures, and dev workflows. In his free time, he likes to practice sports, go to the beach and country-side.
[LinkedIn](https://www.linkedin.com/in/ramigs/) | [Twitter](https://twitter.com/ramigsDev)

**Michael Fatoki Bello**
![Group 562](/uploads/Group_562_c6154b5add.png#small)
Michael is a UI Designer, UXer, and Jamstack enthusiast and ex Creative Director for 8 years managing and building projects for celebs, SMEs and global brands, the hard way (before Figma, Strapi, Vercel or Netlify). He is currently innovating in the Fintech space, eager to solve problems and make awesome and once complicated experiences in a simple and pleasing way. He is always eager to learn and share knowledge and experiences while finding more cool ways to leverage the power of Strapi and the Jamstack to improve UI / UX anywhere content can be served.

[LinkedIn](https://www.linkedin.com/in/michael-f-bello/) | [Twitter](https://twitter.com/lovekaizen)

**Mattias van den Belt**
![Group 546](/uploads/Group_546_76236f2c6d.png#small)
Mattias is a full-time software engineer from The Netherlands, he works at TaskHero and he hopes to finish his Bachelor's degree in Software Engineering, which he follows in the evening hours of the day, in June 2021. He is a young father of one and has a passion for ants and nature. You are most likely to find him in the Community Slack or on the Forum helping others with almost any question about Strapi. If he doesn't know the answer he'll probably jump into the source code to figure something out.
[LinkedIn](http://linkedin.com/in/mattias-van-den-belt) | [Twitter](https://twitter.com/MattieBelt)

**Adegbenga Agoro**
![Group 558](/uploads/Group_558_2766b53941.png#small)
Adegbenga Agoro loves working with budding entrepreneurs in formulating their technology and business strategy plans. With over 17 years of practical experience in Software Design & Development, Business Development, Product Design, Ideation & Management, Business Process Re-engineering, Graphic Design and Design Thinking, Adegbenga seeks to consistently help institutions find the solutions that aid in the achievement of operational and financial improvement and growth. He does this by providing the right tools for the situation per time, optimizing existing business processes and operations and by managing/implementing ground-breaking and innovative solutions and/or products.
[LinkedIn](https://www.linkedin.com/in/adegbengaagoro/) | [Twitter](https://twitter.com/adegbengaagoro)


#### Program Guidelines

The program is currently invite-only. Like we mentioned, consistent activity from people going above and beyond for the Strapi Community warranted the program's creation and thus acts as a prerequisite for an invite into the program.

Putting together and inviting the first set of Community Stars took a huge log out of our eyes, we realised that the Strapi Community could be more diverse. Some would argue that it is a reflection of the state of technology in general but we don't want to make excuses. We've released that there's more we can do and we're choosing to start that journey now and will be sharing more on that in the coming weeks. Our first step on that journey is to make sure it is easy for anyone to contribute to the project. We've put together a[ community resources repository](https://github.com/strapi/community-resources) that tackles many areas (usually underappreciated) that people can use to contribute to open source. If you've been wanting to contribute but feel you don't know how to. This resource is for you ❤️

Speaking of getting involved, we have a couple of ways you can do just that :)

-   Become part of the [Strapi Meetup](https://github.com/strapi/strapi-meetups) Program

-   Contribute the [Strapi Project](https://github.com/strapi/strapi/blob/master/CONTRIBUTING.md) or [FoodAdvisor](https://github.com/strapi/foodadvisor) App

Check out also our [Meetup Kit](https://github.com/strapi/strapi-meetups/blob/master/meetup-kit.md).

If you have any questions about the program, please reach out to Daniel <daniel.phiri@strapi.io> from the DevRel Team or Derrick <derrick.mehaffy@strapi.io> from the Community Team. Stay safe and take care.

In this article, we're super pleased to be sharing the fruits of something that we've been putting together for a few months. Today we're proud to announce the Strapi Community Stars Program.

 Introducing the Strapi Community Stars Program

Exactly 6 years ago today, the first lines of code were committed to the Strapi project repository on GitHub. Back then, Aurélien, Jim and I were working as freelance developers while being students. Frustrated by the limitations of traditional CMS, we decided to create our own piece of software: Strapi. 

![unnamed.png](/uploads/unnamed_9d4248f552.png)


## The Strapi Story

The name Strapi comes from Boot**strap** your **API** because before becoming a Headless CMS, Strapi was a mix between a framework for building APIs and a CMS. 

But the story really began in 2017, when we decided to work full time on the project and rebuild it from scratch based on the feedback from early adopters. We[ released the v3.alpha](https://strapi.io/blog/release-v3-alpha-6), a new website, and new documentation and that’s when the number of users started to grow slowly but surely. 

Fast forward to 2019, everything started to accelerate. The numbers of community members grew exponentially as developers led the shift from traditional to Headless CMS. Thanks to a [$4M seed round](https://strapi.io/blog/announcing-strapi-4m-seed-funding-round) led by Accel, we were able to introduce several game-changing features such as the Dynamic Zones and Components. 

In 2020, Index Ventures preempted our[ $10M Series A](https://strapi.io/blog/announcing-strapi-10m-series-a-funding). COVID-19 acted as a forcing function to transform Strapi, from an office-based company to a worldwide, remote organization. We published the[ stable version of Strapi](https://strapi.io/blog/strapi-stable-community-edition) and announced the[ Enterprise Edition](https://strapi.io/blog/introducing-strapi-enterprise-edition-beta-and-plans). 


![unnamed-2.png](/uploads/unnamed_2_900f101816.png)

In 2021, we have been mostly focused on building a stellar team of 45 full-time passionate Strapiers to execute on our vision to make every type of content accessible anywhere. We hosted StrapiConf, our first user conference back in April and now getting ready to launch [Strapi v4](https://strapi.io/v4) together with an official [plugin Marketplace](https://market.strapi.io/). Visit our website to learn more about our [story](https://strapi.io/about-us) and the Strapi team. 


## The Strapi Birthday Challenge

Now for the fun celebration part 🎉 

How to Join: [strapi.io/birthday](https://strapi.io/birthday) Let's gooo!! 


### Quiz Rules:

The rules are:

- After completing the quiz, a tweet with blanks and the #strapibday hashtag will be displayed. Fill in the blank(s) and send the tweet! Funniest / most creative tweets win prizes. Winners will be announced on twitter.


### Prize:

This is your chance to win one of the 3 swag bags including a branded t-shirt, water bottle, mug, stickers and much more! Winners will be announced at the end of the conference on Twitter.


![unnamed-4.png](/uploads/unnamed_4_81c6a436dc.png)




## Thank you Strapi Community 

None of this would have been possible without the support of the Strapi community. From the feedback of the first users, to all the contributions on GitHub, Open Collective, Discourse, Discord, Youtube, the Strapi community never ceases to amaze us. 

We are truly grateful for your support and contributions and would genuinely love for you to take part in this birthday celebration by sharing a message or memory with us on twitter with the hashtag #strapibday 


large_Blog_thumbnails.png

medium_Blog_thumbnails.png

small_Blog_thumbnails.png

thumbnail_Blog_thumbnails.png

Blog_thumbnails.png

We are happy to announce the release of a new repository within our Github organization: [awesome-strapi](https://github.com/strapi/awesome-strapi)

![Awesome Strapi logo](/uploads/awesome-strapi-logo.png_0b12535cf2.png)

### What is an awesome repo?

It is a repository listing all the awesome resources belonging to a certain technology / service. The [official awesome repository](https://github.com/sindresorhus/awesome) is a list of all kinds of interesting topics:

- Platforms
- Programming Languages
- Front-End Development
- Back-End Development
- Computer Science
- etc ...

Encouraged by the number of Strapi plugins and providers published on NPM, we decided to create our own and [Derrick Mehaffy](https://github.com/derrickmehaffy) took care of creating the structure and the initial list of resources.

As a public repository on GitHub, you can not only consult awesome-strapi but also contribute to it with pull requests!

![Awesome repository](/uploads/Capture-d-e-cran-2020-03-17-a--18.58.12.png_820368d069.png)

Here are the current topics on the repository:

- Documentation, Tutorials, and Meetups
- One-Click & Deployment
- Starters & Examples
- Plugin & Providers
- Ecosystem

You're all invited to contribute links to Strapi resources you find useful and interesting. We can't wait to find out about new plugins, email and upload providers the community has been developing.

Thanks to Derrick for creating this repository, thanks to all for making Strapi awesome through your contributions!

awesome-strapi

Awesome Strapi

One year ago, we were announcing [the State of Strapi](https://blog.strapi.io/the-state-of-strapi/) and its future. 2017 is almost over, so let's see if we did what was announced.

---

### Retrospective

2017 has been an amazing year. Within 12 months, we went from working in our flats to having our **[office in an incubator](https://blog.strapi.io/inside-the-box-january-february-2017/)** in the heart of Paris. We **developed several custom Strapi APIs for customers** and since July we proudly get back **full-time on the project** to release v3@alpha.6, then **v3@alpha.7**.

The **team has also grown up** with two new members [Cyril](https://twitter.com/soupettte) and [Wadii](https://twitter.com/WadiiZaim). It's a pleasure to work with you guys, we can't wait to continue this journey!

##### v3@alpha

The v1 was highly dependent on our online SaaS called [the Studio](https://studio.strapi.io). However, **linking an app with this service was difficult** and not so relevant. On top of that, many of you wanted to be able to easily **install extensible features** in their projects.

This is how v3 was born: a **full open-source and extensible solution to easily build APIs**.

We did our best, with the help of the community, to **develop and release the alpha by the end of the year**. We finally published it, with the following plugins:

 - **Settings Manager**: Edit the configuration and adjust the security rules of your Strapi project.

 - **Content Type Builder**: Define the data structure of your API, create relations and generate code according to your needs within a few clicks.

 - **Content Manager**: Auto-generated content interface. Discover, create and edit the data managed by your API.
 - **Users & Permissions**: Authenticate users and secure your API.

*And here is the result:*

<iframe width="560" height="315" src="https://www.youtube.com/embed/yMl5IcFHA74?rel=0" frameborder="0" gesture="media" allow="encrypted-media" allowfullscreen></iframe>

#### The numbers

We wanted to share a few numbers about Strapi in 2017:

 - **2 412** stars ([give yours](https://github.com/strapi/strapi))
 - **777** users on Slack ([join us](https://slack.strapi.io/))
 - **17** contributors ([become one of them](https://strapi.io/community))
 - **28,8K** downloads
 - **132 498** lines of code
 - **2478** commits
 - **150** forks

The number of **monthly downloads increased by 532%** within the last 5 months, and this only the beginning.

### The future

2018 is going to be an exciting year for us. The backlog is full of features and ideas. After the release of the latest alpha versions, you gave us a lot of **feedback**, reported some **issues** and asked for **new plugins**.

Our main priority is to resolve bugs and make the core more stable. We already started working on it [by fixing a lot of issues](https://github.com/strapi/strapi/issues) during the last few days. We plan to be out of alpha in March and to release the **official 3.0.0 stable version in May**.

#### Next features

Here a short-list of the coming features in 2018:


 - **Users & Permissions 2.0**: Providers authentication (Facebook, Twitter, Github, ...), custom email templates and advanced settings.

 - **Upload**: Easily upload files on the server or storage providers (AWS S3, etc.).

 - **Media Library**: Link images and assets to database entries.
 - **GraphQL**: Finally, turn your Strapi API into a powerful GraphQL endpoint.

The next ones will be upvoted by you. Thanks to a future page on the website, you will be able to define the roadmap and the new coming features. 

#### Analytics

Last but not least, we are going to offer a new analytics plugin at the beginning of February. Every company **needs to track its API usage** and the teams have to follow several metrics: active users, retention, custom events, etc.

We realized that many of them are building a custom dashboard or using third-party solutions which are not perfectly adapted to track an API.

Thanks to its design, Strapi has **a perfect knowledge of your database structure** and **lifecycle events**. That's why we think we are the ablest to **display the most accurate information** about your **API usage and user's activities** without doing anything on your side.

This plugin introduces the second part of our vision about how easy it should be to build and manage an API from A to Z.

### See you in 2018

As you may know, this year has been particularly intense for us. For that reason, **the whole team will be off next week** so we will be less active on Slack and GitHub, but we'll be more than ever in January.

We wish you all the best.

*And you, what would you like for 2018?*

The Strapi team

strapi-year-in-review-2017

Review of 2017

> 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 ❤

large_top_blog_post_2020.png

medium_top_blog_post_2020.png

small_top_blog_post_2020.png

thumbnail_top_blog_post_2020.png

top_blog_post_2020.png

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

**Role-Based Access Control (RBAC)** is a well-known feature to anyone working with Content Management Systems (CMS) or any web application/platform. Today we’re very excited to announce that this feature is available to all Strapi users in the latest version of Strapi (v3.1). The full changelog can be found in the repository [here](https://github.com/strapi/strapi/releases/tag/v3.1.0). 

We’d like to give a special shout out to [@JelmerV-WFC](https://github.com/JelmerV-WFC), [@shaheinm](https://github.com/shaheinm), [@AHgPuK](https://github.com/AHgPuK) for their contributions in this release: 
- Possibility to combine filters with search [#6865](https://github.com/strapi/strapi/pull/6865)
- Make Strapi GraphQL an implementing service for Federation [#6146](https://github.com/strapi/strapi/pull/6146)
- Media Lib improvements [#5971](https://github.com/strapi/strapi/pull/5971)

Until today, Strapi admin users either had full access to all settings and content-types or none. 
With this new feature, you now have the option to define the privileges each admin user should have based on their roles. 

Some of you might be wondering how this is different from the [Roles & Permission plugin](https://strapi.io/documentation/v3.x/plugins/users-permissions.html#concept) already available by default in Strapi, although the names are a bit confusing the difference is actually very simple. That plugin is only directed towards end-users i.e someone who has an account on your site to leave a comment in our article, not admin users who have access to the Strapi admin panel. The Roles & Permissions plugin and its capabilities remain totally unchanged. 

## Role-Based Access Control - Basic vs Advanced

RBAC is not only important to enterprise users but pretty much all of our users, as it is a fairly standard CMS capability. However, from conversations we had with Strapi users, the required level of granularity for these roles & permissions varied greatly based on the profile of our users. 

On one hand, advanced capabilities are often needed by enterprises for security and governance purposes. Large companies often require these privileges to be managed from Single Sign-On (SSO) or Active directory that controls authorization to all accounts and applications from a single service. Stay tuned for more information on that topic in the coming months. 

On the other hand, what personal bloggers and startups really need are more basic RBAC capabilities allowing them to effectively manage permissions for small teams of authors and editors with very limited security or governance requirements.
 
For that reason, and instead of limiting the number of admin users in Strapi Community Edition (CE), we decided to make the basic RBAC capabilities **available to all**, while making more advanced capabilities only available to Strapi Enterprise Edition (EE) customers. Please refer to this [blog post](/blog/introducing-strapi-enterprise-edition-beta-and-plans) for more information on our vision for Strapi EE and paid Plans. 

Let’s take a closer look at the basic and advanced RBAC capabilities available in Strapi today.
 
The basic RBAC feature available in Strapi CE includes an unlimited number of admin users and 3 default roles (Super Admin, Editor, Author) with customizable access to specific Collection & Single Types.

The advanced RBAC feature available in Strapi EE Silver and Gold allows you to create an unlimited number of custom roles (add a new role, edit, delete an existing role) and high level of granularity (down to the field level) for a series of specific actions (Create, Read, Update, Delete, Publish). 

## How to create and manage new roles & permissions in Strapi 

In this example, we will create 4 users with obvious names: they will all be granted with different levels of permissions: 
- John SuperAdmin will be granted SuperAdmin access.
- John Editor will have Editor level permissions
- And John Author and John Authorbis will both have Author permissions.

The Roles & Permissions settings can be configured in Settings > Permissions > Roles. Note that this is not in the Roles and Permissions plugin section, which still handles the users' permissions in the final application.

![Settings-Roles](/uploads/Settings-Roles_768dd41bba.png)

In Strapi Community Edition, 3 roles are available:
- Super-Admin: Super Admins can access and manage all features and settings.
- Editor: Editors can manage and publish content including those of other users.
- Author: Authors can manage and publish only the content they created.

### Roles and Permissions settings view

In the User section of the Permissions settings, you will find all your users and be able to configure them. On user creation, you will have access to a generated URL link that you’ll be able to send to your new user to register.

![User creation](/uploads/User_creation_40aa295001.png)

The Settings menu can only be accessed by the Super Admin, the Settings link in the menu is not shown to Editors and Authors. The first user created when you first log in your application will always be a Super Admin. 

<div style="position: relative; padding-bottom: 56.25%; height: 0;"><iframe src="https://www.loom.com/embed/d947c3638e8f41bb88768537e9a94477" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style="position: absolute; top: 0; width: 100%; height: 100%;"></iframe></div>


### Authors can only access their own content.

The Editors can manage, access, and publish any content created by any users when Authors can only access their own content. 

In the example video below, one article has been created by John SuperAdmin, and one has been created by John Author. John Author will only see his own article in his administration interface, when John Authorbis, will see none.

<div style="position: relative; padding-bottom: 56.25%; height: 0;"><iframe src="https://www.loom.com/embed/56303c400c2e49d4af7deec4464e7fd6" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style="position: absolute; top: 0; width: 100%; height: 100%;"></iframe></div>

In the Enterprise edition, Roles creation is **unlimited**. Role Control is also more advanced, with a **high level of granularity** options, allowing you to configure **CRUD operations for any field available in any content type**.
In our example, we will create an Analyst role, assign this role to John Authorbis, and limit the permissions to *read-only* for the field *Amount* of the Collection Type *Billings*. 

<div style="position: relative; padding-bottom: 56.25%; height: 0;"><iframe src="https://www.loom.com/embed/6c10f36a94104818ab2b3bcb267b8883" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style="position: absolute; top: 0; width: 100%; height: 100%;"></iframe></div>

Permissions can be given **at any level, for any field and for any entry**. You can now easily have multiple users working on the same projects without any chance of interacting with data that they’re not supposed to. 

### Custom Conditions

You can even go one step further by **defining your own conditions of permissions for any users**. For example, let’s define a condition allowing access only to Billings where the Amount is lower than 10K. 

To do so, open the config/functions/bootstrap.js file, and add the following code:

```
module.exports = () => {
 strapi.admin.services.permission.conditionProvider.register({
 displayName: 'Billing amount under 10K',
 name: 'billing-amount-under-10k',
 plugin: 'admin',
 handler: { amount: { $lt: 10000 }},
 });
};
```

After restarting the server, you’ll see the new condition in the Roles settings as follows:

<div style="position: relative; padding-bottom: 56.25%; height: 0;"><iframe src="https://www.loom.com/embed/f3a5349746d9483c98a7c521853c8c43" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style="position: absolute; top: 0; width: 100%; height: 100%;"></iframe></div>

## Logical filtering operators

In this new release, we are also introducing a new way of filtering your data. You will now be able to use logical operators AND and OR to build complex queries without the need for custom code.

### AND operators
Restaurants that have 1 stars and a pricing less than or equal to 20:

```
const query = qs.stringify({
  _where: [{ stars: 1 }, { pricing_lte: 20 }],
});

await request(`/restaurants?${query}`);
// GET /restaurants?_where[0][stars]=1&_where[1][pricing_lte]=20
```

### OR operator
Restaurants that have 1 stars OR a pricing greater than 30:

```
const query = qs.stringify({ _where: { _or: [{ stars: 1 }, { pricing_gt: 30 }] } });

await request(`/restaurant?${query}`);
// GET /restaurants?_where[_or][0][stars]=1&_where[_or][1][pricing_gt]=30
```

This will offer you the freedom to create more diverse and friendlier experiences for your users.
You can find the documentation on how the filtering works and examples here: 
[https://strapi.io/documentation/v3.x/content-api/parameters.html](https://strapi.io/documentation/v3.x/content-api/parameters.html)

## Let's get started

If you already have a Strapi project, a [fully detailed migration guide](https://strapi.io/documentation/v3.x/migration-guide/migration-guide-3.0.x-to-3.1.x.html) is available. You can also check the changelog [here](https://github.com/strapi/strapi/releases/tag/v3.1.0).

If you are new to Strapi, just give it a try!

Take a look at the [Getting Started guide](https://strapi.io/documentation/3.0.0-beta.x/getting-started/quick-start.html#_1-install-strapi-globally) to jump on board, or get started with the following command line:

`yarn create strapi-app my-app --quickstart`

or 

`npx create-strapi-app my-project --quickstart`

## Get involved

Check out our [public product roadmap](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration) to see what features we’ll be working on next.
Don’t see a feature you’d like in the backlog? Feel free to [submit new feature requests](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration) or even better, [start contributing](https://github.com/strapi/strapi/blob/master/CONTRIBUTING.md) to Strapi on GitHub. All contributions and users are welcome!




 Announcing Strapi 3.1 - Administrator Roles & Permissions

We strive to make Strapi a perfect tool for easy and efficient content management. Today, we’re thrilled to get one step closer to this goal as we’re releasing the Draft and Publish feature. 

## What's New? 

The Draft and Publish feature lets you save the content as a draft and publish it whenever you want. Once published, the content can be reverted back to the “unpublished” draft state. This functionality is available for all Strapi users: both in Community and Enterprise edition.

![image2](/uploads/image2_c14ee67dac.png)

## Why is this feature important?

The draft and publish feature is not only about being able to save content as a draft. It lets you be more efficient and organized while dealing with daily content management tasks and working on your project. Let’s have a closer look at what you’ll be able to do with this update.

**1. Flexible Content Management**

The Draft & Publish feature allows Strapi users to draft their work ahead of time across their organization and publish it at the right time. Changes can be made anytime prior to publication and will be instantly saved to make sure they are up-to-date at all times. You can also unpublish any content type if you want to hide them or make additional edits. 

In the following example, we will first create an article and save it as a draft. Then we will publish it, edit the live version, and unpublish the article. Here’s how it works:

<div style="position: relative; padding-bottom: 62.5%; height: 0;"><iframe src="https://www.loom.com/embed/f4e8c97508484f0f9aba77c055bd18bb" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"></iframe></div>

By default, the draft & published states are enabled for all the content types but you can switch this system off. Configuration of the Draft & Publish feature can be made by clicking on the edit icon next to the Content Type’s name as shown below. Beware that if you create drafts and then decide to switch the draft & publish system off for a certain content type, your drafts will be deleted.

<div style="position: relative; padding-bottom: 62.5%; height: 0;"><iframe src="https://www.loom.com/embed/def8be79b8994516a0d838c756cc77a0" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"></iframe></div>

**2. Efficient Teamwork With Permissions Levels**

The [Role-based Access Control feature](https://strapi.io/blog/announcing-3.1-role-based-access-control) released from the 3.1 version of Strapi allows admins to create roles with different levels of permissions. Larger teams can therefore work on the same content.  Authors will be able to write content and save it as drafts, while editors and admins will have permissions to review and publish it. Used together, these features help any publishing team to efficiently manage all the content that is being produced, reviewed, and published. Whether you manage an internal team of writers or occasional freelancers, any publication workflow can be implemented with long-term or occasional permissions. 

If you want to have more granularity and set custom roles, last week we have released Strapi Enterprise Bronze Edition with 30 custom roles, [check it out](https://strapi.io/blog/introducing-bronze-plan-new-hosted-trials-and-starter-library)!

Here’s an example of how an admin can review an article written by the author and publish it. 

<div style="position: relative; padding-bottom: 62.5%; height: 0;"><iframe src="https://www.loom.com/embed/2661f646a453472da03ccd1394511960" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"></iframe></div>

**3. One Hub For All Content**

Forget about a million tabs in your browser and endless copy-pasting as now you can keep all of your content in Strapi. Write, edit, format, publish and unpublish your content in the same place. All the drafts and published materials are systemized inside Strapi and can easily be switched from one state to another.

![image1](/uploads/image1_d9b57b2809.png)

## Upgrade Strapi to v3.2

Be the first one to try the new functionalities! Here’s the [migration guide](https://strapi.io/documentation/v3.x/migration-guide/migration-guide-3.1.x-to-3.2.x.html) to help you update to the newest version. Once updated, check out this [guide](https://strapi.io/documentation/v3.x/concepts/draft-and-publish.html#draft-and-publish) on how to use the feature. 


If you are new to Strapi, welcome! 
Check out the [demo with sample data](https://strapi.io/demo) or [create your project](https://strapi.io/starters) by using one of the starters. 
You can also build your Strapi project by running a quickstart command: 

```
yarn create strapi-app my-project --quickstart
```

## What else in the latest Strapi releases?

Apart from the Draft & Publish feature, we did several bug fixes, translation, and enhancements to make your experience with Strapi smoother.

The full list of updates is available in the [changelog](https://github.com/strapi/strapi/releases). 
Here are some of them: 
- [Users & Permissions plugin](https://github.com/strapi/strapi/pull/7467) is moved to the settings menu
- [Linkedin login](https://github.com/strapi/strapi/pull/7490) is now supported
- [More options](https://github.com/strapi/strapi/pull/7665) allowed to the Apollo Server config

Also, we added a [new template option](https://strapi.io/documentation/v3.x/concepts/templates.html) to the create-strapi-app CLI. With these templates, you can create new Strapi projects that already have content types and plugins pre-configured for you. They're great to share content models across apps with a common use case, like blogs or e-commerce sites. Choose the template for your project in our new [starters library](https://strapi.io/starters) or [create your own template](https://strapi.io/documentation/v3.x/concepts/templates.html#creating-a-template)!

We’d love to hear your feedback about these updates. Share with us what you think on the Strapi [Forum](https://forum.strapi.io/), [Slack](https://slack.strapi.io/), or [Github](https://github.com/strapi/strapi) 

## Chat with the Strapi team on the Online Meetup

To help you keep up with the latest updates and learn how the new features work, we’ve organized an **Online Meetup on Thursday, October 15th at 06:00 PM CEST. **

Our Developer Advocate Daniel and Engineering Lead Alexandre did a demo of the **Draft & Publish** feature in the Admin Panel, discussed its use cases, the changes to API, and what functionality the feature enables for the backend. Finally, we had an update from Sam our Product Manager on the upcoming features.

Have a look at the meetup replay: 

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

## Building Strapi together

We regularly update the public roadmap where you can see what features we’ll be working on next. 

Let us know what features you would love to see in Strapi! Please upvote the features that you want to have, or [submit new feature requests](https://portal.productboard.com/strapi/1-roadmap/tabs/2-under-consideration) on the roadmap if they are not mentioned there. 

Needless to say, we would be happy to see your [contributions](https://github.com/strapi/strapi/blob/master/CONTRIBUTING.md) to Strapi on GitHub and we appreciate every single one of them! 



Announcing Strapi 3.2 with Draft & Publish, Templates and more 

Today, the Strapi team is very excited to announce [StrapiConf](https://www.strapi.io/strapi-conf-2021), a virtual conference that will take place on **April 22nd, 2021 from 9 am to 3 pm PST**, a time slot that we think is the most inclusive of all timezone and geographical locations. 

![gif](/uploads/gif_4260ca12cc.jpeg)

With this **free and virtual conference**, our intention is to bring together all the Strapi users, contributors, customers, and partners from all over the world for a day filled with Strapi learning, collaboration, and networking opportunities. 

From Strapi basics and Headless CMS best practices to insights into how to quickly build JAMStack websites, Mobile Applications, and modern digital experiences, StrapiConf will include content for everyone. Looking out a little further, we’ll share our vision for making Strapi a key enabler of the next revolution of low-code application development, taking advantage of APIs.

No matter your level of expertise with Strapi, Headless CMS in general, or your job title, attendees will get unique opportunities to learn and collaborate with their peers at other companies using Strapi to build modern, content-driven applications. 

The conference will include **2 tracks**, with  **30m talks** and  **10m lightning talks**. The first track will be geared towards **advanced users** and include **technical** Strapi concepts, customer/user stories, and integrations. The 2nd track will be for **Strapi beginners**, **Product and Content Managers**. 

The official schedule will be published in **January** but you can already [pre-register](https://www.strapi.io/strapi-conf-2021) and [submit proposals](https://docs.google.com/forms/d/e/1FAIpQLScUYkXm67c-yHccRYsskeUMWO4uwoWtFsBBElmVlrFYYfUyow/viewform) today! 

Please share the love on Twitter by following [@strapijs](https://twitter.com/strapijs) with the hashtag #StrapiConf and don’t hesitate to reach out to [conf@strapi.io](mailto:conf@strapi.io) if you have any questions. 


---

Get started with Strapi by creating a project, using a starter or trying our instant live demo. Also, consult our forum if you have any questions. We will be there to help you.
<p align="center">
<a href="https://strapi.io/documentation/developer-docs/latest/getting-started/quick-start.html#_1-install-strapi-and-create-a-new-project">
<img src="https://assets.strapi.io/uploads/Get_Started_e4e026ce55.svg#small" />
</a>
<a href="https://strapi.io/starters">
<img src="https://assets.strapi.io/uploads/Starters_9da222d819.svg#small" />
</a>
<a href="https://strapi.io/demo">
<img src="https://assets.strapi.io/uploads/Try_live_demo_af11161cd6.svg#small" />
</a>
</p>
<p align="center">
<a href="https://academy.strapi.io">
<img src="https://assets.strapi.io/uploads/Strapi_Academy_9ff315144a.svg#small" />
</a>
<a href="https://forum.strapi.io">
<img src="https://assets.strapi.io/uploads/Forum_3ab5cad74b.svg#small" />
</a>
</p>
See you soon!

Announcing the first Strapi global user conference! It's a one-day conference for the Strapi Community to learn, contribute, and collaborate on the future of the leading open-source Headless CMS.

Announcing StrapiConf - Our First Global User Conference

medium_Strapi Custom Plugin-32.jpg

small_Strapi Custom Plugin-32.jpg

thumbnail_Strapi Custom Plugin-32.jpg

Strapi Custom Plugin-32.jpg



After the success of [last year’s StrapiConf](https://strapi.io/blog/strapiconf-2021-wrap), we’re looking forward to organizing the second edition of  our global user conference on March 16-17, 2022. . StrapiConf is a unique learning opportunity for developers no matter their level of expertise with Strapi..

Last year, more than 5000 people from 100+ countries around the world joined for this free and virtual conference. This year, StrapiConf is going to be bigger and better! The conference will expand to include two days. The main conference including in-depth technical sessions, networking opportunities, and keynotes featuring industry leaders will happen on March 16th followed by post-conference hands-on workshops on March 17th.

The conference will connect users, customers, and contributors of the Strapi ecosystem and partners from the Jamstack and open source community worldwide to exchange knowledge, best practices, and experience gained around using Strapi.

The event will also cover the latest V4 release, [marketplace](https://market.strapi.io/), and Strapi's roadmap, as well as trending topics in the [Headless CMS](https://strapi.io/what-is-headless-cms) industry.

The conference will remain virtual, as our main goal is to make this event accessible for everyone. But this year, we will be using a new event platform for an even more fun and interactive experience between you, speakers, and others in the Strapi community.

Finally, we will be planning various learning and networking activities throughout the whole conference, so you don’t want to miss out!

We can't wait to learn from the community and meet you again.


### How to Register

The agenda and schedule are still in development but **preregistration is now OPEN!**


[Register Now](https://conf.strapi.io) and stay tuned for more details to be announced. 

**Mark your calendars now 🗓️**

[iCalendar](https://f.hubspotusercontent30.net/hubfs/6893032/StrapiConf%20%202.ics)    [Google](https://calendar.google.com/event?action=TEMPLATE&tmeid=M2dwZHFhYjgwYXEzdDhrcGdtMWw3c2VlZ20gY18yZnIxYmM5N3QwcTc5OW1ldGNtbTBzazYwb0Bn&tmsrc=c_2fr1bc97t0q799metcmm0sk60o%40group.calendar.google.com)



### Want to Speak?

 Calling all Strapi users, partners and contributors! [StrapiConf CFP is now open!](https://forms.gle/xzEuEbgLARzN8jnu6). Submit your talk and join us for a great conference.

Looking forward to seeing old and new faces this year!



medium_top blog post 2020.png

small_top blog post 2020.png

thumbnail_top blog post 2020.png

large_what-is-Product-Marketing.jpg

medium_what-is-Product-Marketing.jpg

small_what-is-Product-Marketing.jpg

thumbnail_what-is-Product-Marketing.jpg

what-is-Product-Marketing.jpg

Marketing an open-core product is deeply linked to education. Product marketers should use traditional marketing techniques only if they apply to their audiences.

Summer (in Europe) just started a month ago, even if we would like to enjoy the lovely weather, the core team and contributors worked hard to provide a bunch of updates and enhancements. From the [Enterprise Edition](/enterprise) to the new [Role-Based Access Control feature](/blog/announcing-3.1-role-based-access-control), the Strapi ecosystem is booming! Let's see this in details below 👇
 
Unfortunately, there has been no online meetup scheduled in July, but don't worry, we will back soon with new formats and even more meetups! Nevertheless, last month, Jeff Meyerson interviewed Pierre (Strapi's CEO) about our product, what is our mission, and the new Headless CMS trend in [Software Engineering Daily](https://softwareengineeringdaily.com/2020/07/10/strapi-headless-cms-with-pierre-burgy/).
 
 
## Company
 
We are thrilled to welcome **Victor** as Customer Success Manager, **Rémi** as Software Engineer, **Daniel** as Developer Advocate, **Samuel** as Product Manager (community-oriented), **Mégane** as Technical Writer and **Anastasiia** as Product Marketing Manager! Victor will help our customers get the most out of Strapi to ensure they successfully reach their business goals, while Rémi will develop new starters to help our users to set up new projects in no time. Talking about starters, Daniel will promote them and the whole product to everyone by participating and attending a lot of conferences and meetups. Feel free to say "Hello 👋", you won't regret it, he's awesome! And last but not least, Samuel will help you as a community member to contribute more and more to the project by improving the collaboration between the core team and contributors, Megane will make the documentation as easy to read as 1,2,3 and Anastasiia will tell you all about what’s coming next and the latest Strapi features.

![newStrapiers](https://assets.strapi.io/uploads/newStrapiers_b0c0966b24.jpeg)
 
 
Oh, I almost forgot him because he was already considered as part of the team, our one and only **[Derrick](https://strapi.io/blog/welcoming-derrick-to-the-strapi-team)**, one of the most active contributors, joined the project as a Solution Engineer last July. He will continue to help everyone find solutions to their issues! We wrote a [dedicated post](https://strapi.io/blog/welcoming-derrick-to-the-strapi-team), check it out!
 
 
We are still looking for new awesome people to join the team. If you want to be part of the journey, send us your [application](https://strapi.io/careers)!

 
## Product
 
Every year, we try to define two milestones at the beginning of the year. This year, one of these was the development of the [Role-Based Access Control feature](https://strapi.io/blog/announcing-3.1-role-based-access-control). As a CMS providing an administration panel, it is mandatory to be able to define the permissions to access specific features. We already received a lot of feedback from the community, they are really good and we couldn't expect a better way to start the summer!
 
This new release was also an excellent opportunity to officially start (in ßeta) the first part of our business model. Following the common open-core model, we are now offering an Enterprise Edition of Strapi. In this edition, you've unlimited access to **Role-Based Access Control**. It also offers exclusive advantages such as customer support and training.
 
If you want to know more about the Enterprise Edition and the [pricing](https://strapi.io/pricing), please read the [official press release](https://strapi.io/blog/introducing-strapi-enterprise-edition-beta-and-plans).
 
Even if summer often rhymes with holidays on the beach, our core developer team is happy to work on developing new features just for you!! Here’s [the roadmap](https://portal.productboard.com/strapi/1-roadmap/tabs/2-under-consideration):
 
- Draft & Publish
- Contributor License Agreement (CLA)
- Plugin API
- Database Layer
 
### Draft & Publish
 
As an **open-source company** and **headless CMS**, our obsession has always been to provide the best developer experience possible. However, once the project is set up, developers hand the projects to the final end-users: the Content Editors. Their goal is to write the best and creative content possible. In order to do that, they need time to think, test, and iterate their ideas.
 
That's why introducing a real draft system was absolutely necessary. Being able to write content, step away, and come back to continue writing is impossible without a drafting feature. The Draft & Publish system will also include another principle: **collaboration**. We don't want to let a user override the content written by another user, even more, when a second user is editing it at the same time. In order to do that, the feature will provide a "Take over" functionality to alert users when another user is already editing an entry. If they want to, they’ll be able to take over the entry to edit it.
 
We plan to release the feature at the end of the quarter, in September.
 
### Contributor License Agreement
 
When we contribute to the project, like any contributor, we have to sign every commit to ensure the DCO robot will accept the PR. Even if the DCO is the lightest way to ensure every commit's author has the right to submit its changes and let everyone use them, the overall process can be painful.
 
To fix that, we decided to ask every contributor to sign a CLA once for all to make the contribution workflow easier. The CLA document will be very close to the DCO one. We plan to use the [CLA assistant](https://github.com/cla-assistant/cla-assistant) open-source library developed by SAP. In other words, it means that as a new contributor you'll have to sign the CLA, otherwise your pull request won't be merged. Then, for the next contributions, you won't have to repeat the process as a CLA isn't associated with the code itself but to a person.
 
### Plugin API
 
Regarding what's coming next in the roadmap, especially the Internationalization feature, we had to invest time in the internal APIs. As we plan to provide this feature as a plugin, we need to continue the development of the Plugin API.
 
More specifically, the Plugin API should provide an abstraction layer to do the following actions:
 
- Inject dependencies
- Add new command in the CLI
- Add new controllers, models, and services
 
In the next few months, we will open an RFC to share the details of the Plugin API implementation.
 
### Database Layer
 
If you are familiar with Strapi, or if you take a look at our [public roadmap](https://portal.productboard.com/strapi/1-public-roadmap/tabs/3-planned) or [issues](https://github.com/strapi/strapi/issues), you know that our current filter system can be optimized. Thus, we also have performance issues in our GraphQL plugin. By harmonizing the way we deal with data and how we filter it, we want to increase the productivity of the core team but also of everyone writing custom code in their Strapi projects.
 
Like the Plugin API, we will come back to you with further details soon.
 
## Conclusion
 
I hope this post has given you more visibility of what we have been doing this summer. If you have any questions, feel free to post a comment below. We look forward to answering you!
 
See you soon 👋


Summer_Updates

#### The fact
As you probably noticed, [Strapi](https://strapi.io/) development has been much slower than expected during the last few months. We know **you have a lot of expectations regarding Strapi v3**. But **we have some good news for you**!

#### Why?
This delay is mainly due to the fact that **we decided to make some development missions**. Because we were working for customers, we could not work properly on [Strapi](https://strapi.io/).

#### Solid projects
However, because we are developing most of our development projects using it, **we did a lot of improvements on Strapi**. Also, these projects are going to receive a huge trafic, so you can be reinsured about the fact that **Strapi will have been tested in solid production environments**. That will also create **strong references for Strapi**, letting you convince people to use this solution to create APIs based on Node.js.

![](/uploads/preview-readme-9.png_5e1ef994e8.png)

#### Full-time on Strapi
As you may expect, this slower period has been very frustrating for us. But, we have a good news for you: we have the pleasure to announce you that **we are now back working full-time on Strapi**.

According to that, we are introducing you the **up-to-date Strapi Roadmap**: https://github.com/strapi/strapi/projects/1.

Thanks again for your support! We are dedicated **to make Strapi V3 one of the easiest, most flexible and powerful solution to build APIs**

We are more than ever **on the road to Strapi v3 release**: `Strapi alpha.5` will be published on the 18th of August, and Strapi `alpha.6` on the 21st of September. At this point Strapi will have stable framework layer based on [Koa 2](https://koajs.com) and a powerful plugins system, which will allow you to **install existing plugins** (Settings Manager, Content Type Builder and Content Manager) and **develop your own plugins**.

In the meantime we are also going to build a **brand new website** and **update the documentation**.

#### The team is growing!

To accelerate our development process and be able to ship the next release quickly, a new developer joined the team a few weeks ago. Cyril will help us to reach our goals thanks to his development skills and marketing knowledges, especially the Settings Manager and the Content Type Builder. Welcome to you Cyril!

#### Want to be part of the adventure?

A lot of new things are coming, especially the release of Strapi v3. If you want to get the latest news about it, feel free to join us on our [public Strapi Slack](https://slack.strapi.io): we created a dedicated `v3` channel.

Also, we made a [survey](https://docs.google.com/forms/d/e/1FAIpQLSfiK9HBCoevQx8ZONHRWKkUyMu7W5F19NjuuRL0XwrpJ63qew/viewform) to collect your opinion. Please answer to it, this is really important for the next steps of the project: [Strapi v3 survey](https://docs.google.com/forms/d/e/1FAIpQLSfiK9HBCoevQx8ZONHRWKkUyMu7W5F19NjuuRL0XwrpJ63qew/viewform).

Stay tuned.

---

Go to [Strapi website](https://strapi.io).

How can I help you? Feel free to submit a PR or [open an issue](https://github.com/wistityhq/strapi/issues/new) on GitHub. Send us an email at [hi@strapi.io](mailto:hi@strapi.io), if you need support or anything else, we will be glad to chat with you. Don’t hesitate to ping us on [Slack](https://slack.strapi.io).

Thanks for reading!

On the road to Strapi v3! 🚀

Strapi Summer Update

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