
The course presentation video
An overview about the course structure, to plan and optimize your learning path
Learn what is Strapi with this introduction
Get an overview of the developer blog application we'll build throughout this course
Install NodeJs using Node Version Manager
Create the Strapi project for our developer blog application
More info on what the Strapi installation script performed for us
How to adopt Typescript for your Strapi project
Learn to distinguish admin users from application users, and get an overview of the admin panel sections
Instructions on how to update Strapi to a more recent version
Learn what Strapi content types are and start creating the Post content type
Explore all field types
Start adding fields to our Post content type
Create our second collection type
Create and understand relation fields
Understand Strapi components and create our first one
Use our first 2 content types to create some content instances by using the Content Manager
Create two new collection types needed for our application
Start creating our first single content type for our blog's Home Page
Learn about dynamic zones and create a first zone
Populate the HomePage single content type with content, thus also learning how to use dynamic zones
Fix the component tree of the Home Page
Creating a CompanyInfo component for setting up global configuration parameters for our site
Explore the Strapi architecture by examining the generated API, content types with their JSON schemas, and the database tables that power default CRUD operations.
A couple of tools to install to follow along with the course
Enable and perform our first public REST API call
Learn how Authentication & Authorization flows work in Strapi
Sign a user up via API
Perform a request as an authenticated user, by applying the needed auth header
Learn how to manually generate tokens to grant access to Strapi API
Learn about the default CRUD endpoints for Collection Types, with examples
Learn about the default CRUD endpoints for Single Types, with examples
Test api parameters with postman using the params tab to pass key value pairs and sort the response by title in ascending order; explore descending order as well.
Explore how to paginate content via API using page number and page size, and the count option, and adjust the page size to control posts per frontend page.
Install the Strapi GraphQL plugin and enable its endpoint
Perform an authenticated GraphQL query by adding the authorization header, publish the page to unlock data, and retrieve fields like title and id from a single type.
Explore fetching nested components and dynamic zones with GraphQL to assemble a home page, including hero components, calls to action, images, and related posts.
Learn how to perform GraphQL mutations to create, update, publish, and delete posts, including setting timestamps and handling drafts, with intuitive operation names and auto suggestions.
Explore GraphQL operators to control responses by filtering fields, applying content filters (title contains 'stroppy'), sorting, and paginating results, including publication state and locale considerations.
Explore how a client request traverses policies, routes, middleware, controllers, and services in the Strapi core, with content types and models guiding data access and response.
Configure core routes in Strapi by customizing built-in routes or creating custom ones, attach policies and controllers, and manage authorization settings for CRUD endpoints.
Create custom routes in Strapi by exporting a routes array from a dedicated file, specifying the method, path, handler, and optional configuration with default policies.
Explore how to implement global, API, and plugin policies in Strapi, attach them to routes, and use policy context and configuration to enforce user roles and access.
Discover the stroppy object, injected into policies, controllers, and services to enable modularity and code reuse; inspect its contents: admin panel, routes, services, controllers, database, and entity manager.
Explore how controllers orchestrate the request‑response flow by using actions, services, and the strapi dot controller interface to customize or replace core controllers, including examples with API and plugin controllers.
Filter premium posts from public requests by adjusting the find action to return only non-premium content for unauthenticated users; discuss moving logic to services and optimizing data queries.
Explore a second Strapi solution that fetches only non-premium posts via the find many service with a premium filter, then sanitize and transform the response for public and authenticated requests.
Develop a cleaner premium posts retrieval by introducing a dedicated public posts service that adds a premium false filter and delegates to the entity service, keeping controller logic slim.
Add a custom Strapi service to update a post's liked by array, passing post id, user id, and query params, then sanitize and populate the updated post for the response.
Explore the theory of lifecycle hooks in Strapi, showing how functions trigger before or after content operations across admin or custom code, with examples like before create and after create.
Create an author content type with required fields and a one-to-one relation to admin users, link posts to authors, and keep authors in sync with admins using lifecycle hooks.
Automatically create and update an author for every admin user using a programmatic lifecycle hook in Strapi, triggered by admin user creation and updates.
Customize GraphQL CRUD operations in Strapi using high-level configurations, disable shadow CRUD, tune the GraphQL playground and Apollo Server, and apply granular controls over specific operations and content types.
Extend the GraphQL schema and resolvers with an extension function using Nexus and SDL, and add a like post mutation with custom resolvers and policies via the extension service.
Extend the GraphQL plugin with a like post mutation by using an extension function and register hook, returning a post entity response and reusing existing post types.
Learn how to shape a GraphQL response in Strapi using the format service and two entity response to return a properly formatted response with only the requested attributes.
Reorganize your GraphQL extension by extracting the post type definition, custom mutation, and configuration into an external file inside a dedicated post GraphQL folder, wrapping resolvers to pass Strapi object.
Master admin server configurations by changing the access url path from /admin to /dashboards, adjusting host and port, and rebuilding the admin panel for development and deployment.
Configure admin panel translations by renaming files, adding an extensions folder, and updating the configuration to set the Italian locale, switch the user language, and customize labels via i18n files.
Explore how to customize the Strapi admin UI by changing the main color and primary colors, adjusting hover and shadow values, and leveraging theme variables and plugins.
Overview and demo of the plugin we'll be developing
We generate our plugin from the CLI and "register" it to the Strapi core
Install dependencies and configure env variables to interact with the Github remote API
We start tweaking the default generated plugin route-controller-service chain to meeting our Github fetching needs
Performing our Github API call to fetch repositories
Enriching and filtering our API response to shape it as an array of "repository" objects
Create the Project content type associated to our plugin
Manually create a test Project entity to be able to start testing our functionalities
Get information for each repo on the existance of an already generated project associated to it
Optimized fetched markdown text for repos to be properly handled in Strapi
Change the plugin logo and create a first custom React component
Introduction to the Strapi UI design system
Fetch Github repositories with an API call from the Admin panel UI of our plugin
Start populating our Admin Plugin UI with a table listing Github repositories
Add dynamic action icons for each repository shown in the table
Add functionality to select/deselect repositories/rows through the checkboxes, individually or in bulk
Change our repo fetching route's policy to allow that operation only for authenticated admin users
Generate a Project programmatically from a single repository via a custom route-controller-service chain
Implement table instant update and alerts to provide proper feedback to user operations
Delete a project programmatically from repository rows
Prevent deleting projects by mistake by adding a confirmation dialog for project deletion
Add buttons to perform bulk project creation/deletion
Generate multiple projects in bulk
Delete multiple projects in bulk
Discover the admin RBAC update in Strapi 4.8, enabling granular permissions and new custom roles for plugins and custom functionalities. These changes broaden plugin permissions, previously limited to enterprise plans.
Apply role-based restrictions that limit the access to the plugin
Admin role-based restrictions for specific routes
Apply the then/catch syntax to properly handle errors
Expose projects for public read access
Translate the plugin in multiple languages
Extract our plugin as a standalone package
Publish the plugin as an npm package on the npm registry
Install the plugin as a remote NPM package, while also learning how to publish a plugin to the Strapi Marketplace
The definitive course to learn Strapi™ v4 from the basics to advanced usage!
Why Strapi and why this course?
This course is perfect for anyone that wants to add Strapi to their developer toolbox, being it the most popular headless CMS in the market (and still growing!), which combines top-level out-of-the-box features with strong flexibility and extensibility.
Build and deploy a complete Strapi app, plus a complete plugin!
In this course I will drive you from the very basic concepts to building, customizing and deploying a complete Strapi application.
The application we'll be creating includes features built by extending the Strapi core via custom logic (routes, controllers, GraphQL resolvers, etc.). Furthermore, in this course you'll be developing a complete plugin (admin + server code), that is ready to be published on the Strapi Market (and in fact you will find it there now!).
Let me say that the Strapi Plugin section is a course in the course, and it will give you the skills to propose Strapi plugins to customers, both through the newborn Strapi market (that has high growth potential) and directly.
Course topics list
Here are the main topics you will be learning:
Working with content: content types, fields, relations, components, dynamic zones
Authorization & authentication system
Working with the REST API
Working with the GraphQL API
Extending Strapi core: custom routes, controllers, services, policies, middleware
Extending the GraphQL plugin
Customizing the Admin Panel
Creating a complete plugin (server and admin included), ready for the Strapi marketplace
Deploying Strapi in production
What you'll be able to do afterwards
By the end of this course, you will feel empowered as you'll master a framework that dramatically speeds up time to market in developing production-ready backend applications, while not sacrificing extensibility to adapt it to endless use cases and business requirements!
Disclaimer
The Strapi™ name and logo are property of Strapi Solutions SAS and are shown, as well as parts of the Strapi application, for educational purposes. This course is published independently, with no affiliation with Strapi Solutions SAS.