Headless CMS

Definitions & benefits

Tools & Concepts

Open source

Features

Authentication

Custom plugins & Marketplace

Webhooks

Multilingual CMS

APIs

Dynamic Zones

User roles & permissions

Content Modeling

Security & Privacy

Use Cases

Ecommerce

Blog

Forum

About Strapi

Life at Strapi

Releases & Roadmap

Events

Community

News

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

Tutorials

How tos

Get all the latest updates, news and events.

Subscribe to the newsletter 📣

Strapi's own cuisine connoisseur, Jim, is constantly on the lookout for the tastiest dishes and the most requested explanations.

After all, you can never have too many ways to explain a concept or a feature. Jim's Recipes are all about that, making sure everyone in the community has access to their preferred method of learning.

Similar to the first [*Recipe Recaps*](https://strapi.io/blog/recipe-recaps-april), we'll be looking through this month's practical walkthroughs. The details of every ingredient Jim chose to use will have you opening up the spice rack to grab bottles as varied as login providers, single types, and emails.

##  Logins with Third-Party Providers

<iframe width="560" height="315" src="https://www.youtube.com/embed/s_vQqQ4tpHs" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

Having more login options can be an important part of welcoming new users. The first item on the menu has Jim going over just that, highlighting how easy it is to set up with Strapi.

Starting with the documentation, there's a lot of information within the [*Login Providers*](https://strapi.io/documentation/3.0.0-beta.x/plugins/users-permissions.html#providers) section. Like any good chef, Jim uses that base information as his guide as he goes through the whole process step by step.

The video really makes it easy to test out the idea with a practical example of adding a new GitHub login option to your app. Don't be afraid of getting your hands dirty and really mixing the bowl of code to make sure you understand how everything works!

## Using Single Types, Components, and Dynamic Zones

<iframe width="560" height="315" src="https://www.youtube.com/embed/eETBV2H6QmM" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

Single Types were explained in the [meetup in early May](https://strapi.io/blog/online-meetup-media-library), going over how content data can be used to create static web pages with Strapi. As the name implies, these are best used for pages that only have one type of content or don't need to be changed very often. 

In the recipe video, Jim cites the old Strapi Company page as an example of an "about us" section that uses Single Types. The video then uses the real world example to help explain how to build something similar. 

From creating the app using components in the content builder to integrating dynamic zones, Jim eases the process of cooking up a nice and professional static webpage. By the end of the video your hunger is sure to be satiated as you walk away with a better understanding of how data construction works in Strapi.

## Email Notifications upon Content Updates

<iframe width="560" height="315" src="https://www.youtube.com/embed/DzUsg1lT8yg" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

Collaboration requires an incredible amount of clear communication and coordination in order to properly function. One way to help smooth the rough edges of remote work and keep the team connected is automatic email updates, and that just happens to be the topic for Jim's next recipe!

A bit of a different flavor from the sauce in the last video, Jim takes on the lesson in a more off-the-cuff format, allowing his experience and expertise with Strapi to guide him through the steps.

While editing code and building a new app, he highlights the importance of relying on the established documentation in order to set up the new feature. [Core Controllers](https://strapi.io/documentation/3.0.0-beta.x/concepts/controllers.html#core-controllers) is one of the major chapters for anyone who wants to learn the details of how to create customized email notifications.

## May More Recipes Follow

So far this month, Jim has already recorded videos on third party logins, single types, and email notifications.

The ingredients for each recipe are easy to find, but it really does help having a master chef guide you through the steps. Beyond the fun idea behind [*Jim's Recipes*](https://strapi.io/blog/jims-recipe-success), we really believe in the benefit of making information as accessible as possible.

More videos are sure to follow, so be sure you [subscribe to the YouTube channel](https://www.youtube.com/channel/UC2w6UgktMHgTS-PN4D0utNw?sub_confirmation=1) to catch them all fresh out of the oven!

If you found any of this month's meals particularly tasty, [tweet about it](https://ctt.ac/A7XN5)!

recipe-recaps-april_cd2fee9717

Recipe Recaps #2

The Strapi community is a real force of inspiration and motivation. The talented individuals around the world take time out of their day to contribute to the code, solving complex (and simple) problems using insights from their personal experiences.

A few releases ago there was an amazing story of someone from the community who helped the Strapi team move faster on a feature. The story starts with how setting up Strapi on Heroku was generally pretty easy and generally ran pretty smoothly. 

There was just one small hiccup that was pretty noticeable. Once in "sleep mode", all images are lost when the server restarts.

However, with a relatively simple function it's easy to upload the images on Cloudinary (or other providers), safely saving the images so they're all still available every time the server comes out of "sleep mode".

That's the simple solution [Kwinten](https://github.com/kwinyyyc) first created that helped solve the issue and made setting up Strapi on Heroku all the easier and smoother.

![P2261323](https://api-prod.strapi.io/uploads/P2261323_a5ce48fed3.jpeg)

## Discovering Strapi

Kwinten first came across Strapi while looking for a specific tool for a freelance job. His search led him to stumbling upon an open-source headless CMS he hadn't heard about before, and he immediately wanted to take it for a test drive.

While reading about the features and use-cases, he noticed that while there was a lot of information around creating blogs with Strapi, there seemed to be a few issues with deployment.

So he created a repo for people like him that wanted to quickly deploy Strapi and try everything out with minimal hassle, choosing to focus on Heroku since it comes with a built-in feature for implementing single-click deployment buttons. The fact that Heroku has an easy-to-setup free option as well made it all the more suited for people looking to easily test out Strapi.

Kwinten then made a pull request and the rest is [history in the logs](https://strapi.io/blog/personal-pull-request-logs-strapi-beta-20).

## Open-Source Community


Since Kwinten's initial solution there have been further changes that make it even easier to set up and use [any upload provider](https://strapi.io/documentation/3.0.0-beta.x/plugins/upload.html#using-a-provider) you want, but his story is a nice reminder of how the community can always help move Strapi forward.

In Kwinten's case, he had worked on open-source projects in the past, but found himself struggling to muster up the motivation to join any new communities or add to any new repos. With so many projects falling victim to bitrot and slowly becoming outdated with fewer and fewer contributors, it's easy to understand why.

Finding the perfect balance of large-enough scale, a decent amount of activity, and simply feeling welcome is at the core of how many people decide if it's worth contributing to an open-source project.

Strapi checked all three boxes for Kwinten, making it easy to find the motivation to work on a new feature and exciting for both himself and the Strapi team to see something so useful come from his code.

We're always looking to welcome new members to the community. If you're interested but not sure where you can help, check out the [product board](https://portal.productboard.com/strapi/1-public-roadmap/) or [write for the community](https://strapi.io/blog/write-for-the-community/) and see if there's anything you can pick up!

If you enjoyed the story, be sure to [Tweet it out](https://ctt.ac/JUYvu)!

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

Ecosystem

kwinten

How Kwinten Solved the Source Provider Problem

Moving fast and evolving to better fit all needs has everyone at Stapi working hard to add the best of the best to the open-source headless CMS. Keeping up with every change and understanding whether or not an update is important for your specific use case is important, but sometimes difficult to fit into the schedule.

To make all that easier and open up a platform to ask questions, [Virginie Ky](https://github.com/virginieky), Frontend Engineer, and [Alexandre Bodin](https://github.com/alexandrebodin), Engineering Lead, hosted a virtual meetup last week, inviting everyone interested in Strapi to learn more about the latest releases and new features.

**Here's a few numbers to start:**

* 154 registrants 👥
* 41 attendees 🔊
* 125 messages 💬
* 73 replays ⏮
* 13 questions ❓

If you missed the webinar, well you’re in luck! You can watch the video of the full event and follow along the useful demos for each new feature:

<iframe width="560" height="315" src="https://www.youtube.com/embed/nr2G-cBA5FY" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

#### New Features

The meetup began with Virginie going over some of the biggest new features added to Strapi in the past few months: [Single Types](https://strapi.io/blog/beta-19-single-types-uid-field), UID fields, and the [Media Library](https://strapi.io/blog/beta-20-media-library).

![Capture-d-e-cran-2020-05-05-a--16.41.01](https://api-prod.strapi.io/uploads/Capture-d-e-cran-2020-05-05-a--16.41.01_f2d23f05aa.png)

###### Single Types
The new Single Types were a significant improvement over using Collection Type to create static content. Along with adding a new data structure, it allows for easy management of one specific instance of data while maintaining the ability to switch between Collection Type and Single Type.

The end result for most people is a simplified process for creating a home page or a portfolio page or any other kind of page!

![Capture-d-e-cran-2020-04-21-a--15.20.32](https://api-prod.strapi.io/uploads/Capture-d-e-cran-2020-04-21-a--15.20.32_7f21e946d5.png)


###### UID Field
The new UID field provides a unique identifier for any given entry, paving the way for Collection Types to have specific and unique identifiers for each of their entries as well. A direct result of that process is readily having access to unique strings that can then generate SEO-friendly URLs.

In other words, the new UID field provides easier access to human-readable (and more memorable) URL slugs that can replace randomly generated ids.

![Capture-d-e-cran-2020-04-22-a--17.35.24](https://api-prod.strapi.io/uploads/Capture-d-e-cran-2020-04-22-a--17.35.24_b9a9b82cd1.png)
 
###### Media Library

The story of the new Media Library starts with the [Strapi product board](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration). After noticing a strong desire for a cohesive and complete Media Library feature, the team got to work and wanted to make sure it would meet the needs of the community.

Going one step further for such a huge new feature, the team also asked all Strapi users to answer a survey about what exactly they would want to see in the [Media Library](https://strapi.io/blog/beta-20-media-library). While it differed from the initial ideas on the product board, that only helped shape a more complete and user-friendly feature for the final release.

![Capture-d-e-cran-2020-05-06-a--16.29.45](https://api-prod.strapi.io/uploads/Capture-d-e-cran-2020-05-06-a--16.29.45_eaee63ddde.png)

#### Questions & Answers

After covering Single Types, UID Field, and the Media Library, Virginie and Alexandre opened up the conversation, giving time for anyone attending to ask questions.

With Strapi fans joining in to share their personal stories and professional use cases, the end of the meetup turned into a fun moment of exchanging ideas on how best to unleash content with Strapi.

Read on for a transcript of all the questions asked with answers from the Strapi team!

**1) Do images retain their original names after being uploaded to the Media Library?**

Yes, when you select a file from your computer and upload it to the Strapi Media Library it keeps its original name. However, it will be cleaned up a bit, removing spaces and standardizing the style. After that Strapi puts a hash at the end of the name so it has a unique ID and that’s basically it.

You can also always change the display name to whatever you want in the Media Library.

**2) Can you define the alt text for images in the Media Library?**

Yes, you can add alternative text to images and it’s easy to see all the available options in the API. Alt text, captions, and more are all a part of the standard API call and are easy to set in the Media Library.

If you upload an image that Strapi can’t process for some reason, you’ll see a smaller thumbnail and an error message saying there are too many images loading in the browser.

Generally, everything is well optimized and when uploading very large images, you’ll also have the option to choose specific sizes (small, medium, or large), and you can automatically use them for a more responsive user experience.

**3) Is the AWS s3 plug-in no longer necessary to upload files to AWS s3?**

All provider plugins still work and of course you can still use them. The [Media Library](https://strapi.io/blog/beta-20-media-library) is basically just the UI front and starts with the default provider: localhost.

You can keep it that way and store everything locally or you can send your files to any provider like AWS s3, Rackspace, Cloudinary, or many others thanks to plug-ins developed by the community.

Search for "Strapi provider upload" on NPM and you’ll see all the available options.

There’s also the Awesome Strapi repo on GitHub that lists some of these providers.

**4) Is it possible to generate the different sized images (small, medium, large) change file formats, e.g. from JPG to PNG with the original as a fallback?**

Not right now.

This isn’t how the default setup works, but the idea is to be open to more extensibility in the future. So what you can do is build your own provider to implement whatever features you need or want.

Jim recently recorded a video that shows how easy it is to do. With 2 functions you can have an upload function and a delete function or anything else!
 

**5) Is it possible to modify the sizes of images?**

Not at the moment. We focused on the most commonly requested features, improving the base formats a bit along the way. However, like with changing file formats, you can always customize how it works to better match your use-case.

**6) How do you choose the size (small, medium, large) of the image via the API?**

At the moment the default behavior is to have all formats returned during the API call. You currently can’t select specific formats, but in the future we may provide filters to only receive URLs for the large image or other options.

**7) Could GraphQL allow for choosing specific options?**

Yes, GraphQL could help with that. You could ask for "formats large" and then receive the large ones.

The thing is though, right now it's just a JSON object and JSON objects have to get it all at once. We want to be able to customize the name of the formats in the future and creating a static type in GraphQL would limit us to whatever we set (e.g. small, medium, large).  

In order to then change that we would then need to do it dynamically at some point in the future and that makes more sense in GraphQL.

**8) Is it possible to customize the UID field?**
 
You can just type whatever you want in the slug field. Strapi will check to see if it already exists and provide other options if that’s the case.

The slug has to be unique so it works with you to make sure it’s something different every time.

**9) Can you share anything you’re working on for the next releases?**

A lot of people are probably going to be excited to hear that we're beginning development of a very big feature: admin permissions!

We’re also working on a draft and publish feature, which will be really cool.

They might not come out in the next small release, but keep your eyes out for the next big release.

**10) Is it possible to generate API documentation through the API?**

Not at the moment, but when you start up a Strapi instance the documentation plug-in generates documentation.

So we have a plug-in that generates a swagger interface. You can then access that and show show the API that it was successfully generated.

**11) Will role based access control be free?**

[On the product board card](https://portal.productboard.com/strapi/1-public-roadmap/c/8-users-roles-permissions-ce-ee) there’s a nice explanation about the differences between the community and enterprise editions of Strapi, specifically what will be included in each version.

Now, the enterprise edition is still in private beta, but the plan is to limit the community edition to three roles (admin, author, and editor) while the enterprise edition will be unlimited.

**12) When will multi-tenancy be available?**

It’s on on the roadmap and. Generally speaking though it’s not something we’ll be focusing on in the short-term, but that could always change. Be sure to [check out the product board](https://portal.productboard.com/strapi/1-public-roadmap/tabs/2-under-consideration) for any updates!

**13) Will the code for enterprise edition be open source?**
 
The license for the enterprise edition will be proprietary as expected. The community edition of Strapi will still be under the MIT license, it’s just the enterprise edition that will have a very specific license.

However, the code will still be publicly available on GitHub for everyone to see and contribute.

#### See You at the Next Meetup!
 
Want to see what will be covered in future meetups? Check out the [strapi-meetups GitHub repo]( https://github.com/strapi/strapi-meetups). You can also suggest new topics if there's anything you want the team to talk about. 

Don't forget, you can always watch the full demos and catch all the discussions from the Q&A session over on Youtube: [What's new in the latest Strapi releases?](https://www.youtube.com/watch?v=nr2G-cBA5FY)

If you enjoyed the story, [Tweet about it](https://ctt.ac/LUh98)!

wrapping-up-virtual-mtup

Wrapping up the Virtual Meetup