Paul Smith’s team developed the new back-end internally, while Limesharp built the front-end. By implementing Storyblok’s technology, Paul Smith’s content teams are now benefiting from more flexibility and can update designs and layouts, schedule content, implement bulk updates, and access data in multiple ways by themselves.

Paul Smith transforms online experience with Storyblok CMS

Sahr that that across the state, fire stations are understaffed, causing firefighters to work crazy hours in order to pick up the slack.

Firefighting staffing shortage affects stations throughout Michigan

It helps to have a regular rhythm to catch-up calls, to reinforce a sense of connection and keep people aligned. Kothmeier also advocates randomised “coffee chats” that bring people together from different teams, strengthening relationships between people who may not otherwise interact.

How to communicate effectively with colleagues and clients: The WFH guide

The countdown to Black Friday has begun. However, this year, it’s expected to look a little more “blue” than black as Australian consumers grapple with sky-high mortgage repayments and higher rents. In fact,

With Black Friday Sales Around The Corner, Storyblok Is Asking If Your Website Holiday-Ready?

Storyblok research reveals that 60% of consumers regularly abandon purchases due to poor website user experience with businesses estimating it costs, on average, AU$108,000 in lost sales per year. There are many things you can do to avoid being one of ...

Ready to ring in the sales? How retailers can prep for holiday season

LiSTNR has retained its number one position as Australia’s largest podcast sales representatives network, reaching more than 7.7 million monthly listeners in September, according to the ...

LiSTNR Remains Australia’s No.1 Podcast Network

YouTube has once again claimed the throne of the top brand in YouthInsight’s Australia’s Top 100 Youth Brands Report 2023, additionally being named the leading entertainment brand of Australi ...

YouTube Tops YouthInsight’s Top 100 Brands For Aussie Gen Zs

Hold the phone! There can only be one winner in Telstra's creative pitch and, as you'll read here, there's two winners.

Telstra Set To Award Its Massive Creative Account To TBWA And Bear Meets Eagle On Fire

Little Black Book, Webshop page speed increased by 50% following Storyblok implementation, along with higher conversion and revenue rates

Paul Smith Transforms Online Presence with Storyblok’s CMS

Leading designer label Paul Smith has partnered with enterprise headless CMS Storyblok to modernise and future-proof its website and customer experience. Paul Smith - with the help of eCommerce specia

Designer label Paul Smith transforms digital store with Storyblok’s CMS

Storyblok

storyblok

When does it make sense to go headless? Web development has drastically evolved in recent years. There are a series of options and possibilities to build websites and web applications. One thing I’ve learned in the 6 years I’ve worked in this industry is that each project and client has its own needs and particularities. We can not and should not apply the same approach and use the same technology stack. For many years, developers have built websites and platforms on top of monolithic Content Management Systems like Drupal or WordPress. As more people used those technologies, their core, and plugins evolved to accommodate various needs, always enabling customizations. The idea of one system doing it all. Using Drupal or WordPress can get as complex, and some projects don’t need the complexity of those technologies, either for reduced scope, budget, or timeline. Not every project needs the complexity and robustness that a full-fledged Content Management System (CMS) brings. We need alternatives. With the rise of Static Site Generators and the JAMstack infrastructure concept, static sites were made dynamic with simple headless CMS, allowing editors to easily add and edit content without changing a line of code. We could build static sites with their speed and high performance while delivering a new website in less time and cost. As technology advanced, we could build more complex web platforms without relying on monolithic infrastructures, giving the front end more flexibility and possibilities for out-of-the-box designs. In this scenario, we started seeing the rise of what experts call a Headless Web Web Application or a Decoupled Infrastructure — a web application where the front end is a different entity than the back end. This approach brings a series of benefits to a web platform or website, but it is not something you should apply to every project. It is important to understand the needs and conditions of that specific project and determine if this is a good opportunity to separate the front and back ends. Before we discuss the aspects and factors that influence decision-making, let’s first understand headless web development and its associated benefits. In this very intuitive and simple article, Catherine Dee gives a very simple explanation of Headless Web Development: “In the simplest terms, headless means “decoupling” the front end and back end, implementing a best-in-class API architecture. You’re separating where the content is stored — the content repository — from the presentation layer on which it’s displayed.” Algolia For instance, an infrastructure like this can make content endlessly reusable, eliminating manual processes like copy and pasting and making editing way easier — change the copy or image in one place, and the change applies everywhere the content is located. As put in this Storyblok article: “A headless CMS is a backend-only content management system that’s built from the ground up as a content repository. The content is then accessible via a RESTful API or GraphQL API for display on any device. This separates your data (the “body”) from how it’s presented (the “head”), hence the term “headless” Storyblok In recent years, this approach has also been considered part of Composable architecture: Composable architecture is a modular approach to software design and development that builds flexible, reusable and adaptable software architecture. It entails breaking down extensive, monolithic platforms into small, specialized, reusable and independent components. This architectural pattern comprises a pluggable array of modular components, such as microservices, packaged business capability (PBC), headless architecture and API-first development that can be seamlessly replaced, assembled and configured to align with business requirements. The New Stack It allows the use of API infrastructure to expose data and functionality to a web application, leveraging third-party services and integrating everything on the front end. Separating the head from the body (data) can be beneficial in some projects. Suppose you have an eCommerce store that needs to be updated across different websites and marketplaces. You don't need to replicate this change manually if you have one source coming from a single Content Warehouse. The same could happen if you have different sources of data to be presented on the same website. You do not always need to put everything under the same infrastructure, and the data must come from different sources and be served to the front end. For instance, we have recently built a Live-Streaming platform where the recordings and live videos come from one place, and the copy with information from each session came from a Content Management System. Instead of putting everything within a CMS and serving it in the front end, we built an architecture where the videos are served directly to the front end. Another important thing to remember is that a project doesn’t need to be monolithic or headless. A web application with some headless or decoupled parts can be monolithic at its core. Let’s say you have a media website with information about your company and a series of news articles and events that must be distributed to other platforms and websites. While most of your content comes from your CMS, the events come from a different database and are served directly to the front end without passing through the CMS. Pros and Cons In a nutshell, the pros of Headless web development are: Better scalability and performance for websites with peak traffic
Multi-channel delivery
More flexibility for designs
faster frontend delivery
Leverage third-party services However, not everything about this approach is beneficial. Some of the constraints of Headless CMS can be: Additional overhead with API development and management
It can get very complex depending on what you’re building
Potential higher costs of development
Fewer layout options and flexibility for editors. When should we consider using Headless? This is what we usually try to cover when we ask ourselves this question: Must have the same information across multiple channels and devices, such as website, App, sub-sites, e-mail, etc.
Provide personalised user interfaces and out-of-the-box experiences.
Performance will impact the web application’s service.
Peak traffic websites and applications that need to be easily scalable.
Website that does not need to have many layout options for editors
Real-time Notifications and Information delivered across different channels.
Reduced Budget or/and reduced timeline.
Must rely on third-party service providers for specific parts of the website. From my experience, the following client profiles or projects can benefit from a headless approach: Small and medium Marketing websites → don’t need all the complexity that Drupal or WordPress offers.
eCommerce and catalogues → require seamless integrations with various channels, such as websites, mobile apps, and marketplaces.
Media and publishing → large volumes of content must be distributed across multiple platforms.
Multi-brand Corporations → Large corporations with multiple brands or subsidiaries can benefit from a headless approach to ensure brand consistency while maintaining individual brand identities.
Governmental Institutions -> distribute the same information across multiple platforms and channels while providing real-time updates. When does it make sense to go headless? Web development has drastically evolved in recent years. There are a series of options and possibilities to build websites and web applications. One thing I’ve learned in the 6 years I’ve worked in this industry is that each project and client has its own needs and particularities. We can not and should not apply the same approach and use the same technology stack. Web development For many years, developers have built websites and platforms on top of monolithic Content Management Systems like Drupal or WordPress. As more people used those technologies, their core, and plugins evolved to accommodate various needs, always enabling customizations. The idea of one system doing it all. Using Drupal or WordPress can get as complex, and some projects don’t need the complexity of those technologies, either for reduced scope, budget, or timeline. Not every project needs the complexity and robustness that a full-fledged Content Management System (CMS) brings. We need alternatives. With the rise of Static Site Generators and the JAMstack infrastructure concept, static sites were made dynamic with simple headless CMS, allowing editors to easily add and edit content without changing a line of code. We could build static sites with their speed and high performance while delivering a new website in less time and cost. As technology advanced, we could build more complex web platforms without relying on monolithic infrastructures, giving the front end more flexibility and possibilities for out-of-the-box designs. In this scenario, we started seeing the rise of what experts call a Headless Web Web Application or a Decoupled Infrastructure — a web application where the front end is a different entity than the back end. This approach brings a series of benefits to a web platform or website, but it is not something you should apply to every project. It is important to understand the needs and conditions of that specific project and determine if this is a good opportunity to separate the front and back ends. Before we discuss the aspects and factors that influence decision-making, let’s first understand headless web development and its associated benefits. In this very intuitive and simple article , Catherine Dee gives a very simple explanation of Headless Web Development: article Catherine Dee “In the simplest terms, headless means “decoupling” the front end and back end, implementing a best-in-class API architecture. You’re separating where the content is stored — the content repository — from the presentation layer on which it’s displayed.” “In the simplest terms, headless means “decoupling” the front end and back end, implementing a best-in-class API architecture. You’re separating where the content is stored — the content repository — from the presentation layer on which it’s displayed.” Algolia Algolia Algolia For instance, an infrastructure like this can make content endlessly reusable, eliminating manual processes like copy and pasting and making editing way easier — change the copy or image in one place, and the change applies everywhere the content is located. As put in this Storyblok article : Storyblok article “A headless CMS is a backend-only content management system that’s built from the ground up as a content repository. The content is then accessible via a RESTful API or GraphQL API for display on any device. This separates your data (the “body”) from how it’s presented (the “head”), hence the term “headless” “A headless CMS is a backend-only content management system that’s built from the ground up as a content repository. The content is then accessible via a RESTful API or GraphQL API for display on any device. This separates your data (the “body”) from how it’s presented (the “head”), hence the term “headless” “A headless CMS is a backend-only content management system that’s built from the ground up as a content repository. The content is then accessible via a RESTful API or GraphQL API for display on any device. This separates your data (the “body”) from how it’s presented (the “head”), hence the term “headless” Storyblok Storyblok Storyblok In recent years, this approach has also been considered part of Composable architecture: Composable architecture is a modular approach to software design and development that builds flexible, reusable and adaptable software architecture. It entails breaking down extensive, monolithic platforms into small, specialized, reusable and independent components. This architectural pattern comprises a pluggable array of modular components, such as microservices, packaged business capability (PBC), headless architecture and API-first development that can be seamlessly replaced, assembled and configured to align with business requirements. Composable architecture is a modular approach to software design and development that builds flexible, reusable and adaptable software architecture. It entails breaking down extensive, monolithic platforms into small, specialized, reusable and independent components. This architectural pattern comprises a pluggable array of modular components, such as microservices, packaged business capability (PBC) , headless architecture and API-first development that can be seamlessly replaced, assembled and configured to align with business requirements. packaged business capability (PBC) headless architecture The New Stack The New Stack The New Stack It allows the use of API infrastructure to expose data and functionality to a web application, leveraging third-party services and integrating everything on the front end. Separating the head from the body (data) can be beneficial in some projects. Suppose you have an eCommerce store that needs to be updated across different websites and marketplaces. You don't need to replicate this change manually if you have one source coming from a single Content Warehouse. The same could happen if you have different sources of data to be presented on the same website. You do not always need to put everything under the same infrastructure, and the data must come from different sources and be served to the front end. For instance, we have recently built a Live-Streaming platform where the recordings and live videos come from one place, and the copy with information from each session came from a Content Management System. Instead of putting everything within a CMS and serving it in the front end, we built an architecture where the videos are served directly to the front end. Another important thing to remember is that a project doesn’t need to be monolithic or headless. A web application with some headless or decoupled parts can be monolithic at its core. Let’s say you have a media website with information about your company and a series of news articles and events that must be distributed to other platforms and websites. While most of your content comes from your CMS, the events come from a different database and are served directly to the front end without passing through the CMS. Pros and Cons In a nutshell, the pros of Headless web development are: Better scalability and performance for websites with peak traffic Multi-channel delivery More flexibility for designs faster frontend delivery Leverage third-party services Better scalability and performance for websites with peak traffic Multi-channel delivery More flexibility for designs faster frontend delivery Leverage third-party services However, not everything about this approach is beneficial. Some of the constraints of Headless CMS can be: Additional overhead with API development and management It can get very complex depending on what you’re building Potential higher costs of development Fewer layout options and flexibility for editors. Additional overhead with API development and management It can get very complex depending on what you’re building Potential higher costs of development Fewer layout options and flexibility for editors. When should we consider using Headless? When should we consider using Headless? This is what we usually try to cover when we ask ourselves this question: Must have the same information across multiple channels and devices, such as website, App, sub-sites, e-mail, etc. Provide personalised user interfaces and out-of-the-box experiences. Performance will impact the web application’s service. Peak traffic websites and applications that need to be easily scalable. Website that does not need to have many layout options for editors Real-time Notifications and Information delivered across different channels. Reduced Budget or/and reduced timeline. Must rely on third-party service providers for specific parts of the website. Must have the same information across multiple channels and devices, such as website, App, sub-sites, e-mail, etc. Provide personalised user interfaces and out-of-the-box experiences. Performance will impact the web application’s service. Peak traffic websites and applications that need to be easily scalable. Website that does not need to have many layout options for editors Real-time Notifications and Information delivered across different channels. Reduced Budget or/and reduced timeline. Must rely on third-party service providers for specific parts of the website. From my experience, the following client profiles or projects can benefit from a headless approach: Small and medium Marketing websites → don’t need all the complexity that Drupal or WordPress offers. eCommerce and catalogues → require seamless integrations with various channels, such as websites, mobile apps, and marketplaces. Media and publishing → large volumes of content must be distributed across multiple platforms. Multi-brand Corporations → Large corporations with multiple brands or subsidiaries can benefit from a headless approach to ensure brand consistency while maintaining individual brand identities. Governmental Institutions -> distribute the same information across multiple platforms and channels while providing real-time updates. Small and medium Marketing websites → don’t need all the complexity that Drupal or WordPress offers. Small and medium Marketing websites eCommerce and catalogues → require seamless integrations with various channels, such as websites, mobile apps, and marketplaces. eCommerce and catalogues Media and publishing → large volumes of content must be distributed across multiple platforms. Media and publishing Multi-brand Corporations → Large corporations with multiple brands or subsidiaries can benefit from a headless approach to ensure brand consistency while maintaining individual brand identities. Multi-brand Corporations Governmental Institutions -> distribute the same information across multiple platforms and channels while providing real-time updates. Governmental Institutions

What is a Headless Web Application, and When Should You Consider Using It?

WordPress is the most popular choice among developers to build websites. Almost half of the web in the world has used WordPress. Its popularity allows the developer to create websites quickly, and its robust plugin ecosystem will help scale the site. But now, technology is developing at an increasing pace, and multiple options are available that make it easier to create websites. The evolving technology provides developers an opportunity to enhance the website performance and access to manage and control the security of an application. In the past, the WordPress structure is monolithic. Hence, the user interface and data access are combined on the same platform. Since the introduction of API on WordPress, it has been used headless, allowing developers to use it as a backend and have a frontend in different projects. Thus, the headless CMS (content management system) offers the best solutions in the new digital experience platforms category. This article will help businesses understand headless CMS and what to consider before migration. What is Headless CMS? It is an API-exclusive, decoupled management system for optimizing the Omni- channel marketing strategy. In simple terms, a headless CMS performs as a digital content repository which enables cross-platform content delivery. However, a headless CMS is also known as content infrastructure or API. It is a cloud-based management system that discrete the backend content (body) from the frontend presentation layer (head). It also facilitates content as a Service (CaaS), which helps content creation and editing within CMS structure and prepares new content for another system. ? How Does Headless CMS Works The front-end developer works on the body (where the content ends) and manages content distribution. The developers use these preferred front–end frameworks and tools to create applications and deploy new channels. For content availability across various platforms like websites, mobile apps, IoT devices, and other digital portals, the REST API and GraphQL API are connected with each API endpoint. This system will show similar content from the repository to blog posts, social media feeds, web pages, and native content on Smartwatch. The content manager and editors are making changes to its back-end interface. Why Migrate to Headless CMS? A headless CMS will provide the freedom to focus on front-end development tasks and access to select the technology familiar with and on the data framework. Finally, it will manage the content editing and delivery part so; the developer can streamline other significant factors. This arrangement is especially beneficial for companies using multiple websites and minimizing costs or simplifying the process. A headless structure allows the organization to centralize content management on a single interface and offers the APIs utilized by companies’ different web pages. The other use of a headless structure is to create front – end project that will represent the company as a brand. With this approach, the companies all products will provide the same look and feel, but each of them has its content and is managed in the same administration panel. Different from CMS like WordPress, in headless CMS, the administration is already paired, maintained, and even hosted. Moreover, a headless CMS will make it easier for people to understand the workflow, whether marketers or writers. It also gives the power to edit the content by everyone. This setup will provide freedom, flexibility, and comfort to enhance performance without third-party integrations. Steps to Migrate Headless CMS If the enterprise thinks that headless solutions are perfectly suitable, then start the journey by the below steps: Create and Understand Storyblok Space To understand space in Storyblok, there is a requirement to set up an account. For this, it requires picking a plan which suits to needs. Go to the price page, start with the project, or try a free testing plan. After the creation of the account, the user can access the panel. Then, select create new space and let’s get started. However, the space is a content repository, and it is a place where all the content is related to one project. Each pace has its elements, data sources, assets, domains, collaborators, and permissions. Let’s take a close look at the left sidebar sections. Like: – Allow creating content types and nested components. Components – In this section, the content is stored, and the marketing team spends lots of time. Content – This folder allows you to configure data of your space and languages of applications, the workflow of content you want to publish, user permission, etc. Settings – All the images are stored and able to achieve through CDN service, optimized and any size. Assets Defining Models From migration to WordPress content to Storyblok, the next step is creating a schema that defines WordPress data structure by creating Post types in Storyblok space. Firstly, go to the pages and posts, called pages, and post in Storyblok. However, the schema of WP includes the fields like title, slug, featured image, content, and date. All these fields are used to migrate the content from WordPress. So, it only requires extending it by adding featured images and content in the Page content type. Then move forward with the Components section, tap on a page created by default, remove the body field and add featured image as type Assets > Images and content as Rich – text. When the page schemas are ready, then move to post. For post content type, the necessary information is required to add, like excerpt, content, featured _image, and relationship to other styles like Authors or categories. Each folder has a default content type associated. In the component section, create Author and category as new Content types and associate the Content-Type relative to each folder relative to each folder by clicking on three dots on the right of the folder and selecting settings. The post content type allows the addition of Single or Multi option fields with source Stories. Migrate Content to Storyblok After determining the situation, you know whether you need a migration script. If required, then start following things. However, the migration script means: Retrieves data from source to CMS Transfer the data Send the information to Storyblok Let’s get understand each point in depth: Retrieves data from source to CMS The most significant thing is to determine how to retrieve the data. But there are three options: API Database server Export functionality Transfer Data After retrieving of data, the following things to manage: Creating new URL HTML/ Plain text to prose mirror Converting strings to an array Fields with different schema Data mapping Send the information to Storyblok The user is required to know three simple things: Management API Limitations Data structure Manual Cleanup After completing above mentioned three steps, it is vital to do the manual cleanup. It is essential to check the final result of the import for the following: Special chars Image resolutions Iframes imported to HTML Custom HTML component in the content Formatting issues So, it is a wrap and ready-to-look at the WordPress importer package. Benefits of Headless CMS Still, if you are unsure whether to switch the content infrastructure, some of the advantages are: Speed Content creators are no longer required to worry about how different platforms will present their content. It’s because any update pushed cuts across all digital platforms. Thus, content production is done at a fast rate. Agility The content model structure allows the headless content structure to support an agile workflow where the marketing team works simultaneously with developers. It will ensure enhanced productivity and constant development. Also, it does not require developers to work in sequence and allows them to change wherever needed. The developers can process the content to display on any presentation layer when it is ready. Platform Management Omni channels will challenge marketers because they require creating content that cuts across all touch points. But, headless CMS allows orchestrating a smooth experience that includes all touch points. Conclusion With the growth of the internet, headless development offers a perfect solution for Omni channel marketing. However, unlike traditional CMS built with a front end, a CMS is back ended content management system. However, using API driven approach will allow the editors to create content on its back-end interface, and the developers are responsible for delivering on multiple platforms. So, if any organization wants to deliver cross– a digital platform experience, go with headless CMS. Also, make all the planning development resources and marketing strategy in advance for effective migration.

Headless WordPress Checklist: What Do You Need to Consider Before Migrating?

JSWorld Conference 2022: Part IV

Creating and publishing high-quality content definitely helps businesses grow, reach new customers, and provide them with a superior digital experience. On the other hand, crap content can even turn buyers away from your business. In this regard, in 2021, in the world of COVID-19, when the Internet began to live an even more active life, and online sales jumped several times, a new life began for CMS solutions. In fact, according to a report by MarketWatch, the CMS industry market size is projected to grow from USD 62.4billion in 2020 to USD 116.2 billion by 2025, at a CAGR of 13.3%. In 2021, we also see a trend towards more and more active use of headless CMS, which allows companies and developers to deliver and manage content as quickly and conveniently as possible. But with so many headless CMS options out there, it’s very difficult to find the right solution for a specific use case. In this article, you will learn what a CMS is, the difference between headless and traditional cms, we will give examples of how and when it is advisable to use a headless cms, and also consider how to choose headless cms. We’ve also compiled a list of the best headless cms on the market, so you can compare them, see features, and finally choose the best headless cms that fit your needs. What is a Headless CMS? Head = Static codes on the frontend, therefore, content can be displayed on just one device. The term “Headless” means no front-end part. Accordingly, the headless CMS includes a back-end, a database, and an API that can be called to distribute content. Publishing content via API allows you to deliver content to any device, browser, or application. This is the main advantage – you do not need to build the backend operation with the frontend for only one source. In addition, there is no requirement for any hosts. Therefore, maintaining headless CMS is easier than non-headless CMS. This leads to improvement of the workflow and collaboration. To some extent, headless CMS is a division of decoupled CMS. Decoupled means that the front-end and back-end are managed separately. In a decoupled system, when content is created and edited in the backend of a website, it is transmitted through an application programming interface (API) and then published in the frontend of the website. How a Headless CMS works Let’s now figure out what exactly is under the hood of headless cms and how it all works. Without a front-end content delivery layer and no content authoring interface, a headless CMS is like a repository of content that is accessed via a REST API or GraphQL API. As a result, the content inside the CMS is no longer tied to a particular or delivery layer. Instead, it’s free to be sent to any channel or device using APIs. template This architecture means that data can be transferred to any part of the network after a request has been made to the repository using the API. This does create advantages for publishing across channels, but it can also create issues for non-technical users. While a decoupled system does have a front-end system, headless cms mean that marketers and non-tech people face certain challenges in presenting content to users. In a headless cms, you will not find preview or WYSIWYG editors, which imposes certain difficulties. Difference Between a Headless and a Traditional CMS We have prepared a small table in which to compare Headless and Traditional CMS. Why and When To Use a Headless CMS? In short, we recommend using a headless CMS in the following cases: When scalability is one of the main issues for your blog When you want to deliver content to multiple channels and platforms. If your business model is built around omnichannel content delivery and your content is available across multiple devices and platforms, then going headless over a traditional CMS is definitely a good choice When Not to Use Headless CMS When your business model is one small website and you’re not planning any frequent or major updates, e.g. if you are running a single website populated with static content that changes infrequently, there might not be a lot to achieve with a headless CMS When you don’t need separate channels except for website Also, before deciding whether to use a headless CMS, you should honestly ask yourself and your team do we need a headless CMS? Honestly, no one but you can answer that question. Right now headless CMSs are considered future-proof mainly because of a clear distinction between the content and presentation. But only understanding your short and long-term goals will help you choose the right for your business needs. content management system So should you always choose a headless CMS over a traditional, monolithic CMS? No. So in summary, should you always choose headless CMS over traditional? The short answer is no of course. There are certain benefits and downsides to choosing a headless CMS. But there are definitely use cases where it makes more sense than going with the traditional CMS. Below we’ve highlighted just a few of these. As with any technology, there are certain benefits and downsides to using headless CMS. But nowadays more and more use cases appear when the use of headless CMS becomes justified. Thus, the decision of Headless CMS vs. Traditional CMS depends on your needs and how you are going to use it. Above were some common use cases, but this list is incomplete since you always have to decide for yourself based on your resources and needs. Pros and Cons Of Using a Headless CMS Pros Compatible and Flexibility: You can deliver your content whenever you want; Security: As the content publishing environment isn’t accessible from the database, using this will prevent malware attacks; Scalable: since the front end and back end are separated, there is no separate time needed for maintenance. This allows you to customize your website anytime without having to compromise the performance; Faster time-to-market: You and your developers can test various hypotheses very quickly; No need to learn specific development languages. Cons You need DevOps: you need a team to manage your content infrastructure and all the frontends you’re using to deliver content to different channels; Added development costs; Limited features for content creators; No content previews: and it is very difficult for marketing teams to edit content. Is a Headless CMS secure? A question that worries a lot of people is – are headless CMS safe? When choosing a headless CMS, you should first look at what technologies they use out of the box. The standard is to use OAuth2. Also, since headless CMS actively uses APIs, they should follow API security best practices. How to Choose a Headless CMS? When choosing from numerous headless CMS, pay attention to the following questions: Find out how your marketing department works and its objectives. How they deliver content and what features they need. Pay attention to the developers too – ask their opinion. Costs: Very few CMS are free (and we have a few here). Knowing what options are available and how far the tiers scale-up will help you plan ahead. Can you scale content without falling off a price cliff? How does the product manage files and image assets? Best Headless CMS Flatlogic Web Application Generator is a product, that can help you generate a content management system based on different technologies and different designs, get the source code and then customize the app as you need and host it wherever you like. Flatlogic web application generator It works very simply: Choose the technology stack: , Vue, Angular, Laravel, Node. , MySQL, PostgreSQL; React js Choose your preferred design; Define the database schema; Generate your cms and get the source code. An important point is that before you can download the project code, you can view it in your personal account. Another advantage of is that with our scheme editor you can create not only different types of data, but also create relationships between them. the Flatlogic Web Application generator Try it for free. Strapi Strapi is an open-source Node.js headless content management system, which means that the entire codebase is available on GitHub and thrives on contributors. Strapi generates a working RESTful API or uses GraphQL for developers in minutes after installation. Data is made available through a customizable API. It’s important to note that Strapi is a self-hosted, not a SaaS content management system. The company will introduce a hosted version in the near future. The primary goal of Strapi is to build a solid API while offering an intuitive admin panel. While Strapi has capabilities to ease the task of managing user sessions and applications, users have encountered occasional problems with the drag-and-drop interface and array data types. Strapi allows you to define the content-type structure that you want, with the ability to define categories such as Text, Date, Media, Password, Relation, and Number. Apart from this, you can also edit the API code to personalize it even further. Strapi also comes with auto-generated documentation, framework integration, and available plugin ecosystems. Setting up a new project with Strapi is really fast, and API creation is very customizable. Notable Features Built-in support RESTful and GraphQL APIs; 100% JavaScript for front-end and CMS; Good admin panel for content editors, fully customizable; Good plugin ecosystem; The biggest drawback with Strapi is the pricing model itself. The free version only supports a limited number of users and roles — and it looks like the Enterprise edition will be the premium version that unlocks wider support. The other problem is that relationships in the database still  do not work as expected. There are no built-in tools for migration data. There is no 2FA. It does not delete automatically unnecessary tables and columns from the database. Typescript is not supported, (and we are in 2021). Storyblok Storyblok is a headless CMS with a great feature – a visual editor for content teams. Storyblok is a pure headless Saas CMS. This makes it easier for editors to make changes themselves, in a similar way to traditional website builders. The cms support , Gridsome, Laravel, Nuxt.js, Gatsby.js, React, Svelte, Next.js, Ruby, Django, In terms of pricing free option is available, with packages ranging from $9 per user, per month. Vue.js Notable Features Support multi-languages by default; Content workflows; You can extend the functionality by using plugins. Pros Visual editor; Datasources; Component-based. Cons Not suitable if you want to use the CMS as a database. DatoCMS The notable thing in DatoCMS is that it is written in GraphQL and is API-based. GraphQL defines the operations supported by the API, including input arguments and possible responses, offering an unfailing contract that specifies the capabilities of an API. DatoCMS also includes a visual content schema builder, webhooks, easy image manipulation, multilingual content, and other features. If you want a CMS that’s easy to use and is highly agreeable with a wide range of other technologies, DatoCMS has a lot to offer. Even the free plan supports GraphQL API, and integrating with site generators like Gatsby or libraries like Next.js or React (used in Gatsby, of course) isn’t a problem. Pros Supports static site generators; Easy to set up; Cons Compared to other CMS the range of features is narrow. Sanity Sanity is one of the best headless CMS on the market, which proves by using it such companies as Nike, Figma, National Geographic, and others. Sanity is very flexible in terms of development. Its customization is very deep, thanks to open-source support, numerous plug-ins, and the ability to create custom components as needed. Engineers can customize the editing environment and React and easily integrate the backend with powerful APIs and rich data modeling capabilities. The product comes with live previews, real-time collaboration, and a full version history out-of-the-box. TL;DR – Sanity has much more freedom, but this requires more technical know-how. using JavaScript Pros Support many technologies including React; Deep customization; Previews for content teams. Cons Deep technical knowledge is needed to set up the product. Directus Directus is a great headless CMS if you have a current SQL database. It is written with vue.js, REST is used for the public API and it is powered by Node.js. Directus is open-source so you can use it free without any limitations. The product suite includes an admin app for editors, a content API for developers, and can be self-hosted for free. Directus allows for flexibility in choosing libraries, tools, and stack for your project, can be hosted or in the cloud. With Directus, developers can connect to content via API or SDK, direct to database, or as a standalone application. Directus also allows non-IT users to manage content through the Admin App. The platform has a strong system, allowing for rollbacks and retrieval of previous versions. version control Notable Features Good customization; 30+ languages supported out of the box; Built-in authentication; No-code app; It is fully decomposed and extensible. Prismic Prismic is a SaaS headless CMS trusted by many big companies such as Google, Netflix, and others.  The product allows you to choose the technology, framework, and language and thereafter easily manage and deliver the content. It supports native integrations with eCommerce platforms. The platform supports the following technologies Node, React, Next, Gatsby, Vue, Nuxt, etc., query content with either their RESTful API or GraphQL, and deploy with a hosting platform such as Zeit, Netlify, Heroku. On the other hand, it’s not a pure free open-source CMS. The basic version is free, but to get all the benefits of this tool, you need to pay for it. Notable Features Internationalization out of the box; Scheduling and previews are possible; Supports many tech stacks. Another open-source headless system, Netlify CMS, can be successfully used with any static generator for a more pleasant and faster web project. The tool is created as a single-page React app. Using Netlify, the content is stored in your Git repository alongside your code for easier versioning, multi-channel publishing, and the option to handle content updates directly in Git. It also enables real-time previews, which helps ensure content is working as intended before being published. Notable Features Git gateway; Intuitive workflow for content teams; Good UI for content makers; Both web-based and command-line services are available; Built-in rich text editor; Can pull all the updates from Github and Gitlab automatically. Contentful Contentful is an API-driven headless CMS that focuses on content and the backend. It is considered one of the best systems for small to medium enterprises. The content can be edited anywhere by any smart device and can be integrated with other services such as Dropbox. Contentful does not consider itself a CMS – it is a content infrastructure or CDN that delivers content. It allows you to create your own content models and define your own schemas to be displayed. Notable Features Rich editor interface and intuitive content modeling; Developers can manage and deliver content via APIs and are free to use their preferred languages and ; frameworks You can also integrate with other services like Dropbox; Microservices architecture. Buttercms Butter CMS is a headless CMS that enables smooth transferring the data from old traditional CMS. ButterCMS can integrate with any framework and also has SDKs + Framework plugins for Ruby, Rails, , PHP, Laravel, .NET, Python, Django, Javascript, React, and more. ButterCMS also boasts features such as custom content types, media library, a CDN for assets, testing environment, webhooks, and more. NodeJS This headless CMS uses flexible content modeling, supports multi-sites and environments, comprehensive revision histories, scheduling, and much much more. Notable Features SEO support; Installing and integrating requires very little time; Built-in WYSIWYG editor; Migration service from traditional CMS; CDN support; Powerful admin interface. On average, it's a good SaaS-based CMS for larger companies, but with some performance issues as users said. Wrapping Up In the article, we have discussed what a Headless CMS is, how to choose them, and how they differ from traditional CMS. We’ve also looked at some of the best headless CMS' on the market. We figured out that at the present time, the future belongs to headless CMS, since you need to deliver content to different devices. In conclusion, we can say for sure that choosing the right headless CMS directly affects your business. All this means the future is bright for the headless approach and we can expect many great things to come. First published here

9 Of The Most Popular Headless CMS' In 2021

Building user interfaces is hard. Building nice interfaces is harder, and building exceptional ones is only achievable by the teams that have the best tooling. Today, we will talk about Storybook, one of the most essential tools in modern front-end development, and see how it helps us in building interfaces. Storybook UI Development Lifecycle Let’s do a small exercise and think about how to build the following interface: a to-do list page. It should allow users to view, create, modify and delete their to-dos. First, set things up: create an empty component and add it to the routing. Then wire the component to the API to be able to manage the to-dos. At this point, we can run the dev server, go to the new page, and finally start building it. First, set things up Now, build the thing: implement various component states. Every time we want to build a different state, we need to update the backend so that it returns correct data to the UI. For example, after building an empty state for the list, we need to create some todos so that we get them from the API and can build a non-empty state. Now, build the thing 🔍 Review Time After all the components are ready and tested, we either deploy our changes to a preview environment or merge and deploy to dev/prod under a feature flag to show to our team. Let’s say we got some feedback from the designers. They asked us to make some visual changes to both the empty and non-empty states of the todo list. Now, we delete all todos, tweak the empty state, create todos, and update the non-empty state. The design feedback is incorporated. We deployed the new version of the page and… found that we caused a regression in one of the states. What do we do? You got it. We will update the backend to return the necessary data and fix the issue. And we’re done - everything works this time. We ship our change and roll out the feature to customers. regression 🤔 Was There Anything to Improve? What we’ve done to build that page was reasonable - setup routing, manipulate the backend state to display what’s needed, review work with the team, incorporate the feedback. But along the way, we had to constantly use the backend API to manipulate the data. Want to work with an empty state? Delete all items. Want to get a non-empty state? Create items. Want to get a state with particular items on the list? Same story. We also introduced a regression in our simple dual-state page. Imagine what happens when you have not two but 10 states of your component. When you have to support every single edge case that can happen. Will you constantly update the data to switch to every state? How long will it take? Thankfully, Storybook helps with exactly that! Let’s see how. See it. Build it. Sorted. Storybook is a frontend development environment. It allows us to build components in isolation, mock hard-to-reach edge cases, write visual & interaction tests, and much more. Storybook 🏖️ Building in Isolation & API Mocking When building a component in storybook, we don’t have to add it to our application routing. In fact, we don’t have to run the app at all, bypassing the authorization and getting to the right page that renders the component. It saves seconds, but those seconds add up to a big waiting time. Since there is no app running, we don’t need to rely on a backend API. Instead, we create a set of mocked responses, such as when there is no data, when there is data, when there is a network error, etc. Then, for each state of the page we want to support, we render a component as a separate storybook page (also known as “story”) and specify what response that particular story should get. mocked responses (also known as “story”) It allows us to develop various states simultaneously without making any changes to the underlying data - everything is mocked and defined in the story itself. 🦾 Automated Testing Feels Much Easier If you tried to write tests for your UI components three years ago, it was probably quite a frustrating experience. Test runners like Vitest or Jest are great for business logic tests, but testing the visual components is a nightmare. Just compare these two screenshots of how the test error looks in Vitest and Storybook when an element you tried to query wasn't found. Vitest Storybook The difference is clear - it’s much harder for a human to parse 100 lines of HTML and understand why the query failed compared to seeing how the component was rendered in the real browser and finding the root cause. Additionally, with tools like storybook-addon-test-codegen, the time to write such tests goes down by an order of magnitude. Simply interact with your story, and the addon generates the test code for you. Copy-paste the generated code and the test is done! Now, if anyone breaks the component, they will know it immediately and won’t ship this broken component to customers. storybook-addon-test-codegen storybook-addon-test-codegen makes writing tests 20x faster! I wrote more about it here: https://maecapozzi.com/newsletter/82 20x faster! https://maecapozzi.com/newsletter/82 💅 Easy Peasy Design Reviews Does this sound familiar: building something for a long time, only to be asked to change a bunch of things? You wish you had shown the result of your work to stakeholders earlier to get some early feedback and keep the number of changes small. It’s easily achievable with Storybook. As you finish working on the stories, say, for one of the page components, put together a PR and deploy your storybook. Then, let your team see the piece that you build and comment solely on that. It will keep your PRs smaller (which is always a great thing), make incorporating the feedback faster, and reduce the mental complexity that you would otherwise have when shipping a big change. deploy your storybook 🕵️ Visual Tests With Chromatic Chromatic is a paid solution developed by the Storybook team. It screenshots your stories and compares them to their baselines (stories captured in the main branch). Whenever there is a change in any of the components, Chromatic highlights it and notifies the engineers. Chromatic main A person responsible for making the PR checks the diff to see if the change is intended or if it’s a UI regression. If the change is expected, they can accept it. If it’s not expected, they can safely fix it before the PR lands. Visual testing catches a lot of UI issues that would otherwise go to production unnoticed. not expected Chromatic snapshots are different from HTML snapshots. An HTML snapshot generated by expect(element).toMatchSnapshot() is a raw HTML that is not parseable by a human eye. Whereas a Chromatic snapshot is a screenshot of the component that preserves all the styles and truly displays what your users will see. Chromatic snapshots are different from HTML snapshots expect(element).toMatchSnapshot() Let’s summarize! Storybook improves UI development by allowing us to build components in isolation, eliminating the need to manipulate backend data for different states. It makes testing intuitive with visual comparisons instead of cryptic errors, streamlines design reviews through easy sharing, and catches regressions with tools like Chromatic. Storybook transforms UI development from a tedious process into an efficient workflow, helping teams create exceptional interfaces with less effort and frustration. Useful Resources: Storybook & their Component Tests Overview
Great guide on how to write component tests from Storybook team
Storybook Test Codegen Storybook & their Component Tests Overview Storybook Component Tests Overview Great guide on how to write component tests from Storybook team how to write component tests Storybook Test Codegen Storybook Test Codegen

Why Every Front-End Team Needs Storybook

Storybook is one of the best tools for building client components. It allows us to create UI in isolation, document it, and even cover it with automated tests. I explained why automated tests are worth pursuing in Why You MUST Have Automated Tests. In this post, we'll go deeper into how to write them efficiently with Storybook. Let's Write a Test We have a form with an email, password fields, and a submit button. The user enters their credentials, submits the form, and sees the confirmation message. Here is what the form looks like: And this is the HTML structure of the form: <form>
  <label for="email">Email</label> <input id="email" type="email" name="email" />
  <label for="password">Password</label> <input id="password" type="password" name="password" />
  <button type="submit">Submit</button>
</form> How to Test? Here are the steps we need to take to write a test for this story: Pick an element to interact with.
Find a user-friendly selector for it (e.g. by aria-role, label, placeholder, text, title, test-id) according to Testing Library's guiding principles.
Write the interaction code (e.g. userEvent.click(selector)).
Return to step 1 to perform the next interaction until the test is ready. The Actual Test There are four elements to interact with. Here is how we can do it: Email and password:
Both fields use an input tag, which translates to role=textbox in Testing Library. They also have a <label> which we will use to narrow the element selection.
We will click on the field to focus it and then type in the value.
The submit button is a button element, that translates to role=button in Testing Library. The text on the button is Submit we will also use it to narrow down the selection.
The confirmation message is a simple text, which we can select by its content. With all that said, we get the code like this: play: async ({ canvasElement }) => {
  const canvas = within(canvasElement);

  // Click and type in the email field
  await userEvent.click(canvas.getByRole("textbox", { name: "Email" }));
  await userEvent.type(canvas.getByRole("textbox", { name: "Email" }), "example@gmail.com");

  // Click and type in the password field
  await userEvent.click(canvas.getByRole("textbox", { name: "Password" }));
  await userEvent.type(canvas.getByRole("textbox", { name: "Password" }), "secret-password");

  // Submit the form
  await userEvent.click(canvas.getByRole("button", { name: "Submit" }));

  // Assert that the confirmation message is displayed
  expect(canvas.getByText("Form submitted successfully")).toBeInTheDocument();
}; It does the job, but writing it is a lot of work. What if there are more steps to take? What if the form is more complex? Making it Easier What if all of this was done for you? Presenting: Storybook Test Codegen Addon! With this addon, simply turn on the recording and interact with your stories. The addon will generate a test code for you! How Does It Work? Whenever you interact with the story in recording mode, the addon determines the type of interaction and target element. Only interactions that can be re-created using Testing Library are recorded, such as click, double click, type, and keydown (for enter and shift keys). The other interactions are ignored. As for the target element, the algorithm prioritizes aria-role, label, placeholder, text, title, and test-id and falls back to CSS selectors if none of the above can be used. (once again, according to Testing Library's guiding principles) Do I Just Copy the Code As Is? While the idea of the library is that it should be enough to copy the code as is, you may still want to make some changes, such as adding assertions and reformatting the code. How Do We Assert Dynamic Elements? If you want to assert that the element is displayed, click on it during the recording. Then, when the test is generated, you can change the code from await userEvent.click(...) to await expect(...).toBeInTheDocument() as long as the test still works as expected, and this click wasn't a required interaction. Add expect before or after the click if the interaction was needed. Lastly Writing tests is crucial for stable software. But it takes time. To keep up with the pace of development, we need to automate this process as much as possible. That is where Storybook Test Codegen comes in handy. Give it a try, and let me know what you think! Useful Resources: Why you MUST write automated tests
Storybook and Storybook Interaction Testing
Storybook Test Codegen
Testing Library's guiding principles Storybook is one of the best tools for building client components. It allows us to create UI in isolation, document it, and even cover it with automated tests . Storybook automated tests I explained why automated tests are worth pursuing in Why You MUST Have Automated Tests . In this post, we'll go deeper into how to write them efficiently with Storybook. Why You MUST Have Automated Tests Let's Write a Test We have a form with an email, password fields, and a submit button. The user enters their credentials, submits the form, and sees the confirmation message. Here is what the form looks like: And this is the HTML structure of the form: <form>
  <label for="email">Email</label> <input id="email" type="email" name="email" />
  <label for="password">Password</label> <input id="password" type="password" name="password" />
  <button type="submit">Submit</button>
</form> <form>
  <label for="email">Email</label> <input id="email" type="email" name="email" />
  <label for="password">Password</label> <input id="password" type="password" name="password" />
  <button type="submit">Submit</button>
</form> How to Test? Here are the steps we need to take to write a test for this story: Pick an element to interact with. Find a user-friendly selector for it (e.g. by aria-role, label, placeholder, text, title, test-id) according to Testing Library's guiding principles. Write the interaction code (e.g. userEvent.click(selector)). Return to step 1 to perform the next interaction until the test is ready. Pick an element to interact with. Find a user-friendly selector for it (e.g. by aria-role, label, placeholder, text, title, test-id) according to Testing Library's guiding principles . Testing Library's guiding principles Write the interaction code (e.g. userEvent.click(selector) ). userEvent.click(selector) Return to step 1 to perform the next interaction until the test is ready. The Actual Test There are four elements to interact with. Here is how we can do it: Email and password: Both fields use an input tag, which translates to role=textbox in Testing Library. They also have a <label> which we will use to narrow the element selection. We will click on the field to focus it and then type in the value. The submit button is a button element, that translates to role=button in Testing Library. The text on the button is Submit we will also use it to narrow down the selection. The confirmation message is a simple text, which we can select by its content. Email and password: Both fields use an input tag, which translates to role=textbox in Testing Library. They also have a <label> which we will use to narrow the element selection. input role=textbox <label> We will click on the field to focus it and then type in the value. The submit button is a button element, that translates to role=button in Testing Library. The text on the button is Submit we will also use it to narrow down the selection. button role=button Submit The confirmation message is a simple text, which we can select by its content. With all that said, we get the code like this: play: async ({ canvasElement }) => {
  const canvas = within(canvasElement);

  // Click and type in the email field
  await userEvent.click(canvas.getByRole("textbox", { name: "Email" }));
  await userEvent.type(canvas.getByRole("textbox", { name: "Email" }), "example@gmail.com");

  // Click and type in the password field
  await userEvent.click(canvas.getByRole("textbox", { name: "Password" }));
  await userEvent.type(canvas.getByRole("textbox", { name: "Password" }), "secret-password");

  // Submit the form
  await userEvent.click(canvas.getByRole("button", { name: "Submit" }));

  // Assert that the confirmation message is displayed
  expect(canvas.getByText("Form submitted successfully")).toBeInTheDocument();
}; play: async ({ canvasElement }) => {
  const canvas = within(canvasElement);

  // Click and type in the email field
  await userEvent.click(canvas.getByRole("textbox", { name: "Email" }));
  await userEvent.type(canvas.getByRole("textbox", { name: "Email" }), "example@gmail.com");

  // Click and type in the password field
  await userEvent.click(canvas.getByRole("textbox", { name: "Password" }));
  await userEvent.type(canvas.getByRole("textbox", { name: "Password" }), "secret-password");

  // Submit the form
  await userEvent.click(canvas.getByRole("button", { name: "Submit" }));

  // Assert that the confirmation message is displayed
  expect(canvas.getByText("Form submitted successfully")).toBeInTheDocument();
}; It does the job, but writing it is a lot of work. What if there are more steps to take? What if the form is more complex? Making it Easier What if all of this was done for you? Presenting: Storybook Test Codegen Addon ! Storybook Test Codegen Addon With this addon, simply turn on the recording and interact with your stories. The addon will generate a test code for you! How Does It Work? Whenever you interact with the story in recording mode, the addon determines the type of interaction and target element. Only interactions that can be re-created using Testing Library are recorded, such as click, double click, type, and keydown (for enter and shift keys). The other interactions are ignored. As for the target element, the algorithm prioritizes aria-role, label, placeholder, text, title, and test-id and falls back to CSS selectors if none of the above can be used. (once again, according to Testing Library's guiding principles ) Testing Library's guiding principles Do I Just Copy the Code As Is? While the idea of the library is that it should be enough to copy the code as is, you may still want to make some changes, such as adding assertions and reformatting the code. How Do We Assert Dynamic Elements? If you want to assert that the element is displayed, click on it during the recording. Then, when the test is generated, you can change the code from await userEvent.click(...) to await expect(...).toBeInTheDocument() as long as the test still works as expected, and this click wasn't a required interaction. Add expect before or after the click if the interaction was needed. await userEvent.click(...) await expect(...).toBeInTheDocument() expect click Lastly Writing tests is crucial for stable software. But it takes time . To keep up with the pace of development, we need to automate this process as much as possible. That is where Storybook Test Codegen comes in handy. Give it a try, and let me know what you think! takes time Storybook Test Codegen Useful Resources: Why you MUST write automated tests Storybook and Storybook Interaction Testing Storybook Test Codegen Testing Library's guiding principles Why you MUST write automated tests Why you MUST write automated tests Storybook and Storybook Interaction Testing Storybook Storybook Interaction Testing Storybook Test Codegen Storybook Test Codegen Testing Library's guiding principles Testing Library's guiding principles

Do Not Write Storybook Tests Manually; Do This Instead!

NativeBook: Toolkit for Building IOS UI Components Inspired by Storybook.js

নেটিভবুক: Storybook.js এর সাথে নেটিভ আইওএস ডেভেলপমেন্ট অভিজ্ঞতা একত্রিত করা

NativeBook: Vereinheitlichung der nativen iOS-Entwicklungserfahrung mit Storybook.js

NativeBook: unificando la experiencia de desarrollo nativo de iOS con Storybook.js

NativeBook : unifier l'expérience de développement iOS natif avec Storybook.js

नेटिवबुक: स्टोरीबुक.जेएस के साथ नेटिव आईओएस विकास अनुभव को एकीकृत करना

NativeBook: Storybook.js を使用したネイティブ iOS 開発エクスペリエンスの統合

NativeBook: Storybook.js로 기본 iOS 개발 경험 통합

NativeBook: Unificando a experiência de desenvolvimento nativo para iOS com Storybook.js

NativeBook: объединение опыта разработки для iOS с помощью Storybook.js

NativeBook: Yerel iOS Geliştirme Deneyimini Storybook.js ile Birleştirme

NativeBook: Hợp nhất trải nghiệm phát triển iOS gốc với Storybook.js

NativeBook：使用 Storybook.js 统一原生 iOS 开发体验

Let's talk about -driven development. We all do it. So, instead of fighting it, let's it with Storybook Actions. console.log upgrade Feature instability and mitigations Storybook actions are a feature of Storybook 6 and 7. There's an to make them work like conventional testing mocks. This would be a welcome change, IMO. active design proposal Knowing that a change is on the horizon, let's focus on the features of the current API that will remain (or migrate easily with codemods). Feature Overview In a fresh Storybook 7 installation ( ), we find two example components configured to use Storybook actions. sandboxes here The included Button stories log the common event — — when clicked. Logs can then be expanded to show full event details. onClick ​Heading stories also log events but this time with custom events and . onLogin onCreateAccount These events are logged when the respective buttons are clicked. Actions pair perfectly with . Interactions are a way to document component states thru simulated user input. Interactions trigger their corresponding actions. Storybook interactions Add actions with argTypes Let's define actions for the example Button component. Open the story file and locate component . meta Add an property if one doesn't exist. argTypes Add an property (this needs to match the component prop name). onClick Set the value to . (The logged text can be anything we like.) { action: "clicked" } // Button.stories.tsx
// (surronding code omitted)
const meta = {
  title: "Example/Button",
  component: Button,
  tags: ["autodocs"],
  argTypes: {
    backgroundColor: { control: "color" },
    onClick: { action: "onClick" },
  },
} satisfies Meta<typeof Button>; Now click your button in Storybook and watch the Actions log! Test actions with interactions Let's add an interaction to the example Button component. Create or find a new story. Add a function to the story object. play Within the , find the button. canvasElement then simulate a click event. // Button.stories.tsx
// (surronding code omitted)
export const Primary: Story = {
  args: {
    primary: true,
    label: "Button",
  },
  play: async ({ canvasElement }) => {
    const canvas = within(canvasElement);
    const button = await canvas.getByRole("button", {
      name: /Button/i,
    });
    await userEvent.click(button);
  },
}; Now the story will run the interaction when it loads. Logging both the interaction and the action — in their respective tabs. Lessons learned -driven development is something I do when driving out a component implementation. It's a quick, cheap way to ensure that events are hooked up (early in the process). console.log But log statements has one : they live in component code. And I'm guilty of pushing a log (or a few dozen) into production. huge drawback Storybook actions let you validate implementation in story files, leaving component code alone. Also published . here

Storybook Actions.. in Action

If you document design systems, I'm about to save you a of time because Storybook comes with lesser-known components for organizing colors, typography, and icons. ton ColorPalette Display color systems with the component. ColorPalette Import . Then render a with a single inside. "@storybook/blocks" ColorPalette ColorItem // system/colors.mdx
import { ColorPalette, ColorItem } from "@storybook/blocks"

<ColorPalette>
  <ColorItem />
</ColorPalette> Create an object with a key and color value. And pass it to the component via the prop. ColorItem color Both key and value are displayed in the UI. <ColorItem colors={{ Apple: "#66bf3c" }} /> Describe with and props. ColorItems title subtitle <ColorItem
+  title="Apple"
+  subtitle="A delicious brand color."
  colors={{ Apple: "#66bf3c" }}
/> Add as many colors to the prop as needed. colors <ColorItem
  title="Apple"
  subtitle="A delicious brand color."
  colors={{
    Apple: "#66bf3c",
+    AppleDark: "#46991f",
+    AppleLight: "#83da5a"
  }}
/> Use any CSS-supported color value. adds gray cross-hatches to indicate translucency — where color functions with non- alpha values are used. ColorItem 1 <ColorItem
  title="Apple"
  subtitle="A delicious brand color."
  colors={{
+    Apple: "rgba(102,191,60,1)",
+    Apple60: "rgba(102,191,60,.6)",
+    Apple30: "rgba(102,191,60,.3)",
  }}
/> See full . ColorPalette API reference Typeset Display typography systems with the Typeset component. Import the Typeset component from @storybook/blocks. // system/typography.mdx
import { Typeset } from "@storybook/blocks";

<Typeset {/* required props */} /> requires four props to render: , , , and . Typeset fontSizes fontWeight sampleText fontFamily and support any supported CSS value (and numbers). fontSizes fontWeight <Typeset
+  fontSizes={["2.875em", "2em", "1.375em", "1em"]}
+  fontWeight="900"
+  sampleText="Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+  fontFamily='"Nunito Sans", "Helvetica Neue", Helvetica, Arial, sans-serif'
/> Create a new Typeset block for every discrete typographical subset. <Typeset
+  fontSizes={["2.875em", "2em", "1.375em", "1em"]}
+  fontWeight="900"
+  sampleText="Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+  fontFamily='"Nunito Sans", "Helvetica Neue", Helvetica, Arial, sans-serif'
/> See full . Typeset API reference IconGallery Display icons with the component. IconGallery Import . Then render a with a single inside it. "@storybook/blocks" IconGallery IconItem // system/icons.mdx
import { IconGallery, IconItem } from "@storybook/blocks"

<IconGallery>
  <IconItem></IconItem>
</IconGallery> Place an icon inside . Then display that icon's name with the prop. IconItem name + import * as Icons from "@storybook/icons";

<IconGallery>
  <IconItem name="Accessibility">
+    <Icons.Accessibility />
  </IconItem>
</IconGallery> Take this further — in React — by dynamically generating all available icons. ## Storybook icons

<IconGallery>
  {Object.entries(Icons)
    .filter(([name]) => name !== "iconList")
    .map(([name, Icon]) => (
      <IconItem name={name}>
        <Icon />
      </IconItem>
    ))}
</IconGallery> See full . IconGallery API reference Learn more… Find in-depth references for each component on the and . Storybook docs page Chromatic YouTube channel Also published . here

Using Storybook's Doc Blocks for Design System Documentation: A Quick Guide

The landscape of children's literature has been transformed dramatically by the advent of technology. In this digital age, the merger of artificial intelligence and literature is creating avenues of discovery and creativity that were unthinkable only a few decades ago. One such innovation is the recently unveiled and AI-enhanced story generation algorithm by , a Tulsa, Oklahoma-based startup. Discover Page Storybooks Global Narratives in the Digital Age: The Discover Page The essence of storytelling is sharing; stories are how we transmit our experiences, values, and dreams from one generation to the next. With its new Discover Page, Storybooks extends this tradition into the digital realm, creating a platform for users worldwide to share their personalized stories with a global audience. This development prompts us to consider the potential of digital platforms in fostering a worldwide storytelling community. The Discover Page serves as a digital library, filled with user-generated narratives that showcase the extraordinary diversity of our global community. It's an embodiment of how technology can transcend borders, creating an interconnected web of shared experiences and narratives. The Fusion of Art and Artificial Intelligence The power of storytelling lies not only in the narrative but also in the presentation. Recognizing this, Storybooks has enhanced its story generation algorithm, utilizing advanced artificial intelligence techniques to create vibrant, detailed images that bring each story to life. This merging of art and AI is a significant stride in the evolution of digital storytelling. It's a testament to how AI can enhance creativity, not suppress it. By generating stunning visuals that captivate young readers, Storybooks' AI-enhanced algorithm augments the narrative, making the reading experience more immersive and engaging. This is an encouraging example of the symbiotic relationship that can exist between AI and the creative arts. A New Wave of Storytelling: AI-Generated Children's Book Library In another groundbreaking move, Storybooks unveiled an AI-generated children's book library. By leveraging advanced AI technology, the platform creates unique, engaging stories that cater to a broad range of interests and age groups. This concept of an AI-generated library opens a new chapter in the dialogue about AI’s role in creative fields. It poses intriguing questions about the future of literature. Can AI-authored books compete with human-authored ones in terms of depth, creativity, and emotional resonance? As technology continues to advance, how will AI's role in content creation evolve? Conclusion The recent developments at Storybooks offer a compelling glimpse into the future of children's literature in the digital age. By leveraging AI to enhance creativity and foster a global storytelling community, the platform is transforming the way we think about and engage with children's stories. As we navigate this uncharted territory, it's fascinating to consider what lies ahead. Will AI become a standard tool in content creation, or will it remain an auxiliary support? How will digital platforms like the Discover Page influence our understanding of community and shared experiences? Only time will tell. Until then, we can marvel at the possibilities and engage in the thought-provoking dialogue these advancements spur. For more insights into the exciting world of AI-enhanced storytelling, visit . www.storybooks.app

Stories, News & Mentions about STORYBLOK

Categories

Trending Topics

Stories, News & Mentions about STORYBLOK

Storyblok’s Stories on HackerNoon

Storyblok's News & Mentions

Categories

Trending Topics