Cloud IDEs For Web Developers – Best Of
As more desktop-based tools and mobile productivity apps shift to the cloud, Cloud-based Integrated Development Environments (IDEs) have become essential for web developers. These cloud IDEs allow you to code, debug, and collaborate directly from your browser, providing a seamless experience for building websites and […]
Coding
Alternatives To Typical Technical Illustrations And Data Visualisations
Alternatives To Typical Technical Illustrations And Data Visualisations Alternatives To Typical Technical Illustrations And Data Visualisations Thomas Bohm 2024-11-08T09:00:00+00:00 2025-03-04T21:34:45+00:00 Good technical illustrations and data visualisations allow users and clients to, in a manner of speaking, take time out, ponder and look at the information […]
Ux
Designing For Gen Z: Expectations And UX Guidelines
Designing For Gen Z: Expectations And UX Guidelines Designing For Gen Z: Expectations And UX Guidelines Vitaly Friedman 2024-10-30T09:00:00+00:00 2025-03-04T21:34:45+00:00 Every generation is different in very unique ways, with different habits, views, standards, and expectations. So when designing for Gen Z, what do we need […]
Ux
CSS Container Queries
In traditional responsive design, we rely on media queries to change styles based on the overall viewport size. This works well for adjusting layouts for different screen sizes, but it falls short when you need components to adapt based on their container’s size. To solve […]
CodingIn traditional responsive design, we rely on media queries to change styles based on the overall viewport size. This works well for adjusting layouts for different screen sizes, but it falls short when you need components to adapt based on their container’s size.
To solve this situation, Container Queries were introduced in CSS. They allow you to apply styles to elements based on the dimensions of their containing block, giving you more granular control over responsive design.
Let’s say we have a Card component, containing an image, title, and a few paragraphs. The Card has two layout modes: horizontal for large screens and vertical for smaller screens.
In the horizontal mode, the image will be on the left, and the title and paragraphs are on the right.
In the vertical mode, the image is on top, and the title and paragraphs are below it.
We want this Card to switch between these two modes. Traditionally, we would wrap the styles around the @media query, for example:
.card {
display: flex;
gap: 4rem;
}
.card .featured-img {
width: 40%;
}
.card .content {
width: 60%;
}
@media screen and (width <= 720px) {
.card {
flex-direction: column;
}
.card .featured-img {
width: 100%;
}
.card .content {
width: 100%;
}
}
The problem here is that Media Queries only account for the viewport size, not the container size. If the Card is placed inside a container with a width of 500px, the Card will still be in the horizontal mode, even though it’s not suitable for the container size. We may end up with the content and the image being squished, or the image overflowing the container.
This is one example where Container Queries can be useful. With Container Queries, we can apply styles based on the container’s size, instead of just the viewport size.
To use them, we will need to wrap our .card with a new container. In this example, we will name it .card-container. Then we can add it with the container-type: inline-size declaration.
.card-container {
container-type: inline-size;
width: 100%;
}
The inline-size value specifically enables querying the inline dimension, usually the width in horizontal writing modes of a container.
When we set container-type: inline-size on an element, we’re essentially telling the browser to treat that element as a container whose width can be queried using Container Queries. This is required for applying styles based on the size of the container, rather than the viewport. The width is also important to ensure the container takes up the full width of its parent.
Now, we can apply the styles based on the container’s size in addition to the Media Queries:
@container (max-width: 720px) {
.card {
flex-direction: column;
}
.card .featured-img {
width: 100%;
}
.card .content {
width: 100%;
}
}
The two cards from our example should now switch to the vertical layout when the container’s width is less than 720px, regardless of the current viewport size.
Browser Compatibility
| Browser | Desktop Version | Mobile Version |
|---|---|---|
| Google Chrome | 105 and later | 105 and later |
| Mozilla Firefox | 109 and later | 109 and later |
| Safari | 16.4 and later | 16.4 and later |
| Microsoft Edge | 105 and later | 105 and later |
| Opera | 91 and later | 91 and later |
| Internet Explorer | Not supported | Not supported |
| Samsung Internet | N/A | 20.0 and later |
Inspirations
We’ve walked through a very common use case of using Container Queries. We can actually do so much more with them to create more innovative features on our website, such as combining them with animations, interactive elements, and more. Here are some demos of using Container Queries for your inspiration.
CSS Container Query House
You can resize the container size vertically or horizontally and see the house expand with more rooms and windows.
See the Pen CSS Container Query House by Arco (@Lumocra) on CodePen.
See the Pen Responsive House with CSS Container Query by Gayane Gasparyan (@gayane-gasparyan) on CodePen.
Squish CSS Container Queries
Click the button Add Squishy to add more squishies inside the block and see how their reaction changes the more you add as there isn’t enough room inside.
See the Pen CSS Container Queries by Max Swann (@maxcswann) on CodePen.
The post CSS Container Queries appeared first on Hongkiat.
Snappy Scroll with CSS Scroll Snap
CSS Scroll Snap was introduced to allow you to define snap points for scrollable elements. It ensures that the scrolling lands precisely at the desired points. This new CSS feature is especially useful for creating carousels, slideshows, or any layout where you want to control […]
Coding
Rethinking The Role Of Your UX Teams And Move Beyond Firefighting
Rethinking The Role Of Your UX Teams And Move Beyond Firefighting Rethinking The Role Of Your UX Teams And Move Beyond Firefighting Paul Boag 2024-07-29T18:00:00+00:00 2025-03-04T21:34:45+00:00 In my experience of building and supporting UX teams, most of them are significantly under-resourced. In fact, the term […]
Ux
Rethinking The Role Of Your UX Teams And Move Beyond Firefighting
Paul Boag 2024-07-29T18:00:00+00:00
2025-03-04T21:34:45+00:00
In my experience of building and supporting UX teams, most of them are significantly under-resourced. In fact, the term “team” can often be a stretch, with many user experience professionals finding themselves alone in their roles.
Typically, there are way more projects that impact the user experience than the team can realistically work on. Consequently, most UX teams are in a constant state of firefighting and achieve relatively little in improving the overall experience.
We can complain about being under-resourced as much as we want, but the truth is that our teams are unlikely to grow to a size where we have sufficient staff to address every detail of the experience. Therefore, in this post, I want to step back and reconsider the role of user experience professionals and how UX teams can best improve the user experience of an organization.
What Is The Role Of A UX Professional?
There is a danger that as UX professionals, we focus too much on the tools of our trade rather than the desired outcome.
In other words, we tend to think that our role involves activities such as:
- Prototyping
- User research
- Interface design
- Testing with users
But these are merely the means to an end, not the end goal itself. These activities are also time-consuming and resource-intensive, potentially monopolizing the attention of a small UX team.
Our true role is to improve the user experience as they interact with our organization’s digital channels.
“
This reframing of our role opens up new possibilities for how we can best serve our organizations and their customers. Instead of solely focusing on the tactical activities of UX, we must proactively identify the most impactful opportunities to enhance the overall customer experience.
Changing How We Approach Our Role
If our goal is to elevate the customer experience, rather than solely executing UX activities, we need to change how we approach our role, especially in under-resourced teams.
To maximize our impact, we must shift from a tactical, project-based mindset to a more strategic, leadership-oriented one.
“
As I help shape UX teams in organizations, I achieve this by focusing on four critical areas:
- The creation of shared resources,
- The provision of training,
- The offering of consultative services and
- The building of community.
Let’s explore these in turn.
The Creation Of Resources
It is important for any UX team to demonstrate its value to the organization. One way to achieve this is by creating a set of tangible resources that can be utilized by others throughout the organization.
Therefore, when creating a new UX team, I initially focus on establishing a core set of resources that provide value and leave an impressive impression.
Some of the resources I typically focus on producing include:
- User Experience Playbook
An online learning resource featuring articles, guides, and cheatsheets that cover topics ranging from conducting surveys to performing AB testing. - Design System
A set of user interface components that can be used by teams to quickly prototype ideas and fast-track their development projects. - Recommended Supplier List
A list of UX specialists that have been vetted by the team, so departments can be confident in hiring them if they want help improving the user experience. - User Research Assets
A collection of personas, journey maps, and data on user behavior for each of the most common audiences that the organization interacts with.
These resources need to be viewed as living services that your UX team supports and refines over time. Note as well that these resources include educational elements. The importance of education and training cannot be overstated.
The Provision Of Training
By providing training and educational resources, your UX team can empower and upskill the broader organization, enabling them to better prioritize and champion user experience improvements. This approach effectively extends the team’s reach beyond its limited internal headcount, seeking to turn everybody into user experience practitioners.
This training provision should include a blend of ‘live’ learning and self-learning materials, with a greater focus on the latter since it can be created once and updated periodically.
Most of the self-learning content will be integrated into the playbook and will either be custom-created by your UX team (when specific to your organization) or purchased (when more generic).
In addition to this self-learning content, the team can also offer longer workshops, lunchtime inspirational presentations, and possibly even in-house conferences.
Of course, the devil can be in the details when it comes to the user experience, so colleagues across the organization will also need individual support.
The Offering Of Consultative Services
Although your UX team may not have the capacity to work directly on every customer experience initiative, you can provide consultative services to guide and support other teams. This strategic approach enables your UX team to have a more significant impact by empowering and upskilling the broader organization, rather than solely concentrating on executing design artifacts.
Services I tend to offer include:
- UX reviews
A chance for those running digital services to ask a UX professional to review their existing services and identify areas for improvement. - UX discovery
A chance for those considering developing a digital service to get it assessed based on whether there is a user need. - Workshop facilitation
Your UX team could offer a range of UX workshops to help colleagues understand user needs better or formulate project ideas through design thinking. - Consultancy clinics
Regular timeslots where those with questions about UX can “drop in” and talk with a UX expert.
But it is important that your UX team limits their involvement and resists the urge to get deeply involved in the execution of every project. Their role is to be an advisor, not an implementer.
Through the provision of these consultative services, your UX team will start identifying individuals across the organization who value user experience and recognize its importance to some degree. The ultimate goal is to transform these individuals into advocates for UX, a process that can be facilitated by establishing a UX community within your organization.
Building A UX Community
Building a UX community within the organization can amplify the impact of your UX team’s efforts and create a cohesive culture focused on customer experience. This community can serve as a network of champions and advocates for user experience, helping spread awareness and best practices throughout the organization.
Begin by creating a mailing list or a Teams/Slack channel. Using these platforms, your UX team can exchange best practices, tips, and success stories. Additionally, you can interact with the community by posing questions, creating challenges, and organizing group activities.
For example, your UX team could facilitate the creation of design principles by the community, which could then be promoted organization-wide. The team could also nurture a sense of friendly competition by encouraging community members to rate their digital services against the System Usability Scale or another metric.
The goal is to keep UX advocates engaged and advocating for UX within their teams, with a continual focus on growing the group and bringing more people into the fold.
Finally, this community can be rewarded for their contributions. For example, they could have priority access to services or early access to educational programs. Anything to make them feel like they are a part of something special.
An Approach Not Without Its Challenges
I understand that many of my suggestions may seem unattainable. Undoubtedly, you are deeply immersed in day-to-day project tasks and troubleshooting. I acknowledge that it is much easier to establish this model when starting from a blank canvas. However, it is possible to transition an existing UX team from tactical project work to UX leadership.
The key to success lies in establishing a new, clear mandate for the group, rather than having it defined by past expectations. This new mandate needs to be supported by senior management, which means securing their buy-in and understanding of the broader value that user experience can provide to the organization.
I tend to approach this by suggesting that your UX team be redefined as a center of excellence (CoE). A CoE refers to a team or department that develops specialized expertise in a particular area and then disseminates that knowledge throughout the organization.
This term is familiar to management and helps shift management and colleague thinking away from viewing the team as UX implementors to a leadership role. Alongside this new definition, I also seek to establish new objectives and key performance indicators with management.
These new objectives should focus on education and empowerment, not implementation. When it comes to key performance indicators, they should revolve around the organization’s understanding of UX, overall user satisfaction, and productivity metrics, rather than the success or failure of individual projects.
It is not an easy shift to make, but if you do it successfully, your UX team can evolve into a powerful force for driving customer-centric innovation throughout the organization.
(vf, il)
:where() – CSS: Cascading Style Sheets
Managing CSS can be tricky, especially when styles need to override each other. This often makes it hard to keep the styles in the right places. To simplify things, the :where selector was added in CSS. This is a special CSS selector that allows you […]
Coding
A Look Into: CSS “:is” Selector
The CSS :is selector is a handy pseudo-selector that simplifies complex selector queries. It allows you to group multiple selectors into a single, more readable form, which can help reduce redundancy and make your CSS more maintainable. Before the :is selector, you’d need to repeat […]
Coding
10 Alternative Frameworks to Laravel
While Laravel is popular for its rich features and ease of use, there are many other PHP frameworks that might better suit your needs. In this article, we will explore 10 great alternatives to Laravel, each with its own unique strengths and features. Whether you’re […]
CodingWhile Laravel is popular for its rich features and ease of use, there are many other PHP frameworks that might better suit your needs.
In this article, we will explore 10 great alternatives to Laravel, each with its own unique strengths and features. Whether you’re looking for something lightweight, highly customizable, or built for high performance, I believe there’s an option here for you.
Without further ado, let’s jump in to see the full list.
FrameworkX
FrameworkX is a lightweight PHP microframework created by Christian Luck, designed for building high-performance, real-time applications. It uses an event-driven, non-blocking architecture based on ReactPHP components, making it ideal for high-concurrency and real-time updates such as chat apps and live notifications.
Unlike Laravel, FrameworkX is minimalistic and doesn’t include built-in features like an ORM, templating engine, or expressive helper functions. This minimalism provides flexibility, allowing you to choose and integrate your own preferred libraries for templating, database abstraction, and other functionalities.
Check out our post on how to get started with FrameworkX.
PHP Minimum Requirement: 7.1
PROS
- High-performance and real-time capabilities
- Lightweight and minimalistic
- Event-driven architecture based on ReactPHP components
CONS
- Requires more manual integration to incorporate other features
- Less expressive syntax compared to Laravel
- Requires some getting used to if you are not familiar with event-driven architecture
CodeIgniter
CodeIgniter is a lightweight PHP framework originally developed by EllisLab and now maintained by the CodeIgniter Foundation. Similar to Laravel, it follows a more structured architecture and offers many essential features for an MVC framework.
However, it lacks some of Laravel’s expressive syntax, like the Eloquent ORM and built-in front-end integrations. Despite this, its simplicity makes it easy to pick up for developers with fair experience in PHP, object-oriented programming, and MVC concepts.
PHP Minimum Requirement: 8.1
PROS
- Lean, minimal, and easy to learn
- Good documentation and community support
- Built-in page cache module
CONS
- Smaller ecosystem compared to Laravel
- No built-in ORM
- No built-in templating engine like Blade
- Lack of expressive syntax
- Lack of built-in front-end integration
Laminas
Laminas, formerly known as Zend Framework, is a PHP framework designed for enterprise-grade applications. It offers a collection of professional PHP packages for developing web applications and services. These components are framework-agnostic and comply with PSR (PHP Standard Recommendations), so they can be used outside Laminas.
Laminas differs significantly from Laravel. While Laravel focuses on developer experience, rapid development, and includes full-stack features built-in like Eloquent ORM and Blade, Laminas offers a more modular approach. It provides more flexibility but may require more configuration and setup time compared to Laravel.
PHP Minimum Requirement: 8.1.0
PROS
- Highly modular and customizable
- Strong focus on security and enterprise-level features
- Scalable and suitable for large-scale applications
- First-party ecosystem: Mezzio, API Tools, and MVC framework
CONS
- Less expressive syntax
- No built-in CLI, ORM, and templating engine
- May require more manual integration for some of its components
Slim
Slim is a PHP micro-framework developed by Josh Lockhart that focuses on essentials like routing, middleware, and HTTP request handling.
Unlike Laravel’s full-stack approach, Slim does not include a full MVC layer, a native template engine, or a database abstraction layer, so you’ll need to use your own preferred libraries and components if you need one.
This minimal footprint, however, makes Slim a great choice if you’re looking to create lightweight RESTful APIs or microservices.
PHP Minimum Requirement: 8.1
PROS
- Lightweight and fast
- Simple and easy to use
- Ideal for small to medium-sized projects and APIs
- Extensible with middleware and third-party components
CONS
- Limited built-in features compared to full-stack frameworks
- Requires additional libraries for ORM and templating engine
Nette
Nette is a mature and feature-rich PHP framework created by David Grudl. It offers a comprehensive set of tools and components for building web applications, including a powerful templating engine called Latte, forms handling, database abstraction, and many other components.
Nette differs from Laravel in its focus. While Laravel prioritizes developer experience with features like Eloquent ORM, Blade, and the Artisan CLI included and pre-configured, Nette provides its first-party components separately. This allows you to choose which tools and libraries you’d need to include in your project. Despite its modularity, it provides a base application or skeleton to help you quickly start your projects.
PHP Minimum Requirement: 8.1
PROS
- Matured and battle-tested framework, built since 2004
- Comprehensive set of tools and components for building websites
- Provides base or skeleton with flexible structure
- Powerful templating engine: Latte
- Good documentation and community support
CONS
- Less opinionated than Laravel
- Requires more manual configuration and setup
- Smaller ecosystem compared to Laravel
Phalcon
Phalcon is a unique PHP framework. Unlike the others, it is delivered as a C extension. Designed to optimize speed by bypassing PHP’s interpreter and leveraging lower-level system resources directly, it includes full-stack features like a first-party ORM library, router, caching, and more.
Phalcon sets itself apart from Laravel with its architecture as a C extension. Unlike Laravel, which is implemented purely in PHP, Phalcon requires installing a PHP extension, so you need to be comfortable with commands like apt and PHP .ini configuration files to enable the extension. I think Phalcon is ideal for projects where performance is critical and can handle heavy workloads with minimal overhead.
PHP Minimum Requirement: 8.0
PROS
- High performance due to its nature as a C extension
- Full-stack features included like ORM, caching, dependency injection, i18n, templating engine, and router
CONS
- Requires installing a PHP extension, which can be overwhelming for beginners
- Much smaller ecosystem compared to Laravel
Yii2
Yii2 is a PHP framework created by Qiang Xue, offering extensive features like an ORM, RESTful API, debugging tools, a boilerplate generator, and much more.
Yii2, I think, is quite similar to Laravel in its approach and principles. Unlike some frameworks where features are in separate modules, Yii2 has them built-in and pre-configured with MVC architecture. It also provides a starter kit with basic interfaces and functionality, similar to Laravel Breeze. Additionally, Yii2 also provides solid first-party modules like the Mailing module, i18n module, Docker for localhost, a first-party templating engine, and front-end integration with Bootstrap.
PHP Minimum Requirement: 7.3
PROS
- Support for PHP 7.3, if you still need it
- One of the earliest frameworks in PHP. It’s solid and battle-tested
- First-party modules and tools included and pre-configured
- Gii, one of its unique features to generate codes
- Great documentation and community support
CONS
- Smaller ecosystem compared to Laravel
- Less expressive syntax compared to Laravel
- Has a somewhat unusual namespacing pattern
Spiral
Spiral is a high-performance PHP framework developed by the team at Spiral Scout. It is built around RoadRunner, a PHP application server written in Go, which enables it to handle heavy workloads efficiently and reduce the overhead that may commonly occur in traditional PHP applications.
Spiral uses a classic MVC approach and features a routing system similar to Laravel. However, it exclusively runs with RoadRunner, offering twice the performance out of the box compared to typical PHP MVC frameworks. It also includes components like JOBS, Worker, and BirdDog, specifically optimized for RoadRunner, leading to more optimized and faster applications.
PHP Minimum Requirement: 8.1
PROS
- High performance due to its integration with RoadRunner
- General-purpose framework that allows you to build MVC, CQRS, Event-Driven, and CLI apps
- First-party ORM library, CycleORM, which I think looks neat!
CONS
- Some learning curves, probably requires learning RoadRunner and how it works
- Smaller ecosystem compared to Laravel
Neutomic
Neutomic is a lightweight PHP framework designed for environments that require long-running processes. Built on top of RevoltPHP, Neutomic supports event-driven, non-blocking I/O operations, making it efficient for handling concurrent tasks.
Neutomic differs from Laravel in its use of an event-driven, non-blocking architecture, while Laravel uses a traditional synchronous design by default. Neutomic requires third-party libraries for features like ORM and templating, whereas Laravel includes these features built-in. To get started with an example of a Neutomic application, you can check out the skeleton repository at neutomic/skeleton.
PHP Minimum Requirement: 8.3
PROS
- Lightweight and minimalistic
- High-performance and efficient for handling concurrent tasks
- Event-driven architecture based on RevoltPHP and Amp components
CONS
- Requires more manual integration to incorporate other features, but it provides a skeleton to help you get started
- Less expressive syntax compared to Laravel
- Requires some getting used to if you are not familiar with event-driven architecture
The post 10 Alternative Frameworks to Laravel appeared first on Hongkiat.
Useful Customer Journey Maps (+ Figma & Miro Templates)
Useful Customer Journey Maps (+ Figma & Miro Templates) Useful Customer Journey Maps (+ Figma & Miro Templates) Vitaly Friedman 2024-07-08T10:00:00+00:00 2025-03-04T21:34:45+00:00 User journey maps are a remarkably effective way to visualize the user’s experience for the entire team. Instead of pointing to documents scattered […]
Ux
Useful Customer Journey Maps (+ Figma & Miro Templates)
Vitaly Friedman 2024-07-08T10:00:00+00:00
2025-03-04T21:34:45+00:00
User journey maps are a remarkably effective way to visualize the user’s experience for the entire team. Instead of pointing to documents scattered across remote fringes of Sharepoint, we bring key insights together — in one single place.
Let’s explore a couple of helpful customer journey templates to get started and how companies use them in practice.
.course-intro{–shadow-color:206deg 31% 60%;background-color:#eaf6ff;border:1px solid #ecf4ff;box-shadow:0 .5px .6px hsl(var(–shadow-color) / .36),0 1.7px 1.9px -.8px hsl(var(–shadow-color) / .36),0 4.2px 4.7px -1.7px hsl(var(–shadow-color) / .36),.1px 10.3px 11.6px -2.5px hsl(var(–shadow-color) / .36);border-radius:11px;padding:1.35rem 1.65rem}@media (prefers-color-scheme:dark){.course-intro{–shadow-color:199deg 63% 6%;border-color:var(–block-separator-color,#244654);background-color:var(–accent-box-color,#19313c)}}
This article is part of our ongoing series on UX. You might want to take a look at Smart Interface Design Patterns 🍣 and the upcoming live UX training as well. Use code BIRDIE to save 15% off.
AirBnB Customer Journey Blueprint
AirBnB Customer Journey Blueprint (also check Google Drive example) is a wonderful practical example of how to visualize the entire customer experience for two personas, across eight touch points, with user policies, UI screens and all interactions with the customer service — all on one single page.
Now, unlike AirBnB, your product might not need a mapping against user policies. However, it might need other lanes that would be more relevant for your team. For example, include relevant findings and recommendations from UX research. List key actions needed for the next stage. Include relevant UX metrics and unsuccessful touchpoints.
Whatever works for you, works for you — just make sure to avoid assumptions and refer to facts and insights from research.
Spotify Customer Journey Map
Spotify Customer Journey Blueprint (high resolution) breaks down customer experiences by distinct user profiles, and for each includes mobile and desktop views, pain points, thoughts, and actions. Also, notice branches for customers who skip authentication or admin tasks.
Getting Started With Journey Maps
To get started with user journey maps, we first choose a lens: Are we reflecting the current state or projecting a future state? Then, we choose a customer who experiences the journey — and we capture the situation/goals that they are focusing on.
Next, we list high-level actions users are going through. We start by defining the first and last stages and fill in between. Don’t get too granular: list key actions needed for the next stage. Add the user’s thoughts, feelings, sentiments, and emotional curves.
Eventually, add user’s key touchpoints with people, services, tools. Map user journey across mobile and desktop screens. Transfer insights from other research (e.g., customer support). Fill in stage after stage until the entire map is complete.
Then, identify pain points and highlight them with red dots. Add relevant jobs-to-be-done, metrics, channels if needed. Attach links to quotes, photos, videos, prototypes, Figma files. Finally, explore ideas and opportunities to address pain points.
Free Customer Journey Maps Templates (Miro, Figma)
You don’t have to reinvent the wheel from scratch. Below, you will find a few useful starter kits to get up and running fast. However, please make sure to customize these templates for your needs, as every product will require its own specific details, dependencies, and decisions.
- User Journey Map Template (Figma), by Estefanía Montaña B.
- Customer Journey Mapping (PDF), by Taras Bakusevych
- End-To-End User Experience Map (Figma), by Justin Tan
- Customer Journey Map Template (Figma), by Ed Biden
- Customer Journey Map Template (Miro), by Matt Anderson
- Customer Journey Map (Miro), by Hustle Badger
- Customer Experience Map Template (Miro), by Essense
- The Customer Journey Map (Miro), by RSPRINT
Wrapping Up
Keep in mind that customer journeys are often non-linear, with unpredictable entry points and integrations way beyond the final stage of a customer journey map. It’s in those moments when things leave a perfect path that a product’s UX is actually stress-tested.
So consider mapping unsuccessful touchpoints as well — failures, error messages, conflicts, incompatibilities, warnings, connectivity issues, eventual lock-outs and frequent log-outs, authentication issues, outages, and urgent support inquiries.
Also, make sure to question assumptions and biases early. Once they live in your UX map, they grow roots — and it might not take long until they are seen as the foundation of everything, which can be remarkably difficult to challenge or question later. Good luck, everyone!
Meet Smart Interface Design Patterns
If you are interested in UX and design patterns, take a look at Smart Interface Design Patterns, our 10h-video course with 100s of practical examples from real-life projects — with a live UX training later this year. Everything from mega-dropdowns to complex enterprise tables — with 5 new segments added every year. Jump to a free preview. Use code BIRDIE to save 15% off.
100 design patterns & real-life
examples.
10h-video course + live UX training. Free preview.
(yk)
Introduction to FrameworkX
PHP has come a long way and continues to improve with new features, syntax, and speed. The ecosystem is also expanding, with many developers creating frameworks to simplify the lives of other developers. Popular, full-featured frameworks like Laravel and Symfony exist, as do lightweight microframeworks […]
CodingPHP has come a long way and continues to improve with new features, syntax, and speed. The ecosystem is also expanding, with many developers creating frameworks to simplify the lives of other developers. Popular, full-featured frameworks like Laravel and Symfony exist, as do lightweight microframeworks like FrameworkX.
It is a lightweight microframework for PHP that uses an event-driven, non-blocking architecture, similar to Node.js which is perfect for high-concurrency and real-time applications like chat apps or live notifications.
In this article, we will explore what FrameworkX is and how it differs from traditional PHP frameworks. Let’s get started!
Getting Started
First, make sure you have PHP and Composer set up on your computer. Once installed, you can add FrameworkX to your project with this command:
composer require clue/framework-x
FrameworkX doesn’t require a complex setup. All you need is a public/index.php file. Here’s a basic example to display “Hello World!” on the homepage:
<?php
require dirname(__DIR__) . '/vendor/autoload.php';
$app = new FrameworkXApp();
$app->get('/', fn () => ReactHttpMessageResponse::plaintext("Hello world!n"));
$app->run();
To run your application, type:
php public/index.php
This command starts a local server using PHP’s built-in server, backed by the ReactPHP Socket component. No need for Nginx or Apache. Your server will run at http://127.0.0.1:8080, and it should display “Hello World!”.
Besides plain text, you can also return JSON data. For example:
<?php
require dirname(__DIR__) . '/vendor/autoload.php';
$users = [['name' => 'Jon Doe'], ['name' => 'Jane Doe']];
$app = new FrameworkXApp();
$app->get('/', fn () => ReactHttpMessageResponse::json($users));
$app->run();
Async Operations
PHP operations are usually blocking and synchronous, meaning each task must finish before the next one starts. FrameworkX is built on the ReactPHP library.
ReactPHP is a library that provides components such as the EventLoop, Stream, Promise, Async, and HTTP components, which enable asynchronous operations. Thus, tasks can run concurrently without waiting for others to finish. This is ideal for handling multiple connections, HTTP requests, or I/O operations simultaneously.
In this example, we’ve updated our index.php to fetch an API. Instead of using the curl_* functions, we will use the HTTP component to make an asynchronous request.
$app = new FrameworkXApp();
$app->get('/', function () {
echo "Startn";
(new ReactHttpBrowser())
->get('https://www.hongkiat.com/blog/wp-json/wp/v2/posts')
->then(function () {
echo "End (API)n";
});
echo "Endn";
return ReactHttpMessageResponse::plaintext("Hello world!n");
});
$app->run();
Normally, an external API request would block the page from rendering until the request completes. However, with the asynchronous operations that the ReactPHP HTTP component handles, the page loads instantly, as evidenced by the log.
This makes FrameworkX capable of handling many more concurrent requests than traditional PHP setups, significantly speeding up page load times. But how fast is it?
Speed
I tested FrameworkX on a basic, inexpensive DigitalOcean droplet with 1 vCPU and 1GB of RAM. It handled around 4,000 requests per second effortlessly.
Concurrency Level: 50 Time taken for tests: 22.636 seconds Complete requests: 100000 Failed requests: 0 Keep-Alive requests: 100000 Total transferred: 17400000 bytes HTML transferred: 1300000 bytes Requests per second: 4417.69 [#/sec] (mean) Time per request: 11.318 [ms] (mean) Time per request: 0.226 [ms] (mean, across all concurrent requests) Transfer rate: 750.66 [Kbytes/sec] received
Even with additional workload, like disk read operations and rendering 100 lists from a JSON file, it still managed around 2700 requests per second.
Concurrency Level: 50 Time taken for tests: 36.381 seconds Complete requests: 100000 Failed requests: 0 Keep-Alive requests: 100000 Total transferred: 296700000 bytes HTML transferred: 280500000 bytes Requests per second: 2748.72 [#/sec] (mean) Time per request: 18.190 [ms] (mean) Time per request: 0.364 [ms] (mean, across all concurrent requests) Transfer rate: 7964.31 [Kbytes/sec] received
I’m pretty sure it could be much faster with better server specifications.
Wrapping Up
FrameworkX is a powerful, lightweight microframework for PHP. It runs asynchronously and is capable of handling multiple tasks efficiently, similar to Node.js. It’s the perfect framework whether you’re building a simple app or complex high-concurrency or real-time applications.
The post Introduction to FrameworkX appeared first on Hongkiat.
How To Improve Your Microcopy: UX Writing Tips For Non-UX Writers
How To Improve Your Microcopy: UX Writing Tips For Non-UX Writers How To Improve Your Microcopy: UX Writing Tips For Non-UX Writers Irina Silyanova 2024-06-28T10:00:00+00:00 2025-03-04T21:34:45+00:00 Throughout my UX writing career, I’ve held many different roles: a UX writer in a team of UX writers, […]
Ux
How To Improve Your Microcopy: UX Writing Tips For Non-UX Writers
Irina Silyanova 2024-06-28T10:00:00+00:00
2025-03-04T21:34:45+00:00
Throughout my UX writing career, I’ve held many different roles: a UX writer in a team of UX writers, a solo UX writer replacing someone who left, the first and only UX writer at a company, and even a teacher at a UX writing course, where I reviewed more than 100 home assignments. And oh gosh, what I’ve seen.
Crafting microcopy is not everyone’s strong suit, and it doesn’t have to be. Still, if you’re a UX designer, product manager, analyst, or marketing content writer working in a small company, on an MVP, or on a new product, you might have to get by without a UX writer. So you have the extra workload of creating microcopy. Here are some basic rules that will help you create clear and concise copy and run a quick health check on your designs.
Ensure Your Interface Copy Is Role-playable
Why it’s important:
- To create a friendly, conversational experience;
- To work out a consistent interaction pattern.
When crafting microcopy, think of the interface as a dialog between your product and your user, where:
- Titles, body text, tooltips, and so on are your “phrases.”
- Button labels, input fields, toggles, menu items, and other elements that can be tapped or selected are the user’s “phrases.”
Ideally, you should be able to role-play your interface copy: a product asks the user to do something — the user does it; a product asks for information — the user types it in or selects an item from the menu; a product informs or warns the user about something — the user takes action.
For example, if your screen is devoted to an event and the CTA is for the user to register, you should opt for a button label like “Save my spot” rather than “Save your spot.” This way, when a user clicks the button, it’s as if they are pronouncing the phrase themselves, which resonates with their thoughts and intentions.
Be Especially Transparent And Clear When It Comes To Sensitive Topics
Why it’s important: To build trust and loyalty towards your product.
Some topics, such as personal data, health, or money, are extremely sensitive for people. If your product involves any limitations, peculiarities, or possible negative outcomes related to these sensitive topics, you should convey this information clearly and unequivocally. You will also need to collaborate with your UX/UI Designer closely to ensure you deliver this information in a timely manner and always make it visible without requiring the user to take additional actions (e.g., don’t hide it in tooltips that are only shown by tapping).
Here’s a case from my work experience. For quite some time, I’ve been checking homework assignments for a UX writing course. In this course, all the tasks have revolved around an imaginary app for dog owners. One of the tasks students worked on was creating a flow for booking a consultation with a dog trainer. The consultation had to be paid in advance. In fact, the money was blocked on the user’s bank card and charged three hours before the consultation. That way, a user could cancel the meeting for free no later than three hours before the start time. A majority of the students added this information as a tooltip on the checkout screen; if a user didn’t tap on it, they wouldn’t be warned about the possibility of losing money.
In a real-life situation, this would cause immense negativity from users: they may post about it on social media, and it will show the company in a bad light. Even if you occasionally resort to dark patterns, make sure you can afford any reputational risks.
So, when creating microcopy on sensitive topics:
- Be transparent and honest about all the processes and conditions. For example, you’re a fintech service working with other service providers. Because of that, you have fees built into transactions but don’t know the exact amount. Explain to users how the fees are calculated, their approximate range (if possible), and where users can see more precise info.
- Reassure users that you’ll be extremely careful with their data. Explain why you need their data, how you will use it, store and protect it from breaches, and so on.
- If some restrictions or limitations are implied, provide options to remove them (if possible).
Ensure That The Button Label Accurately Reflects What Happens Next
Why it’s important:
- To make your interface predictable, trustworthy, and reliable;
- To prevent user frustration.
The button label should reflect the specific action that occurs when the user clicks or taps it.
It might seem valid to use a button label that reflects the user’s goal or target action, even if it actually happens a bit later. For example, if your product allows users to book accommodations for vacations or business trips, you might consider using a “Book now” button in the booking flow. However, if tapping it leads the user to an order screen where they need to select a room, fill out personal details, and so on, the accommodation is not booked immediately. So you might want to opt for “Show rooms,” “Select a rate,” or another button label that better reflects what happens next.
Moreover, labels like “Buy now” or “Book now” might seem too pushy and even off-putting (especially when it comes to pricey products involving a long decision-making process), causing users to abandon your website or app in favor of ones with buttons that create the impression they can browse peacefully for as long as they need. You might want to let your users “Explore,” “Learn more,” “Book a call,” or “Start a free trial” first.
As a product manager or someone with a marketing background, you might want to create catchy and fancy button labels to boost conversion rates. For instance, when working on an investment app, you might label a button for opening a brokerage account as “Become an investor.” While this might appeal to users’ egos, it can also come across as pretentious and cheap. Additionally, after opening an account, users may still need to do many things to actually become investors, which can be frustrating. Opt for a straightforward “Open an account” button instead.
In this regard, it’s better not to promise users things that we can’t guarantee or that aren’t entirely up to us. For example, in a flow that includes an OTP password, it’s better to opt for the “Send a code” button rather than “Get a code” since we can’t guarantee there won’t be any network outages or other issues preventing the user from receiving an SMS or a push notification.
Finally, avoid using generic “Yes” or “No” buttons as they do not clearly reflect what happens next. Users might misread the text above or fail to notice a negation, leading to unexpected outcomes. For example, when asking for a confirmation, such as “Are you sure you want to quit?” you might want to go with button labels like “Quit” and “Stay” rather than just “Yes” and “No.”
Tip: If you have difficulty coming up with a button label, this may be a sign that the screen is poorly organized or the flow lacks logic and coherence. For example, a user has to deal with too many different entities and types of tasks on one screen, so the action can’t be summarized with just one verb. Or perhaps a subsequent flow has a lot of variations, making it hard to describe the action a user should take. In such cases, you might want to make changes to the screen (say, break it down into several screens) or the flow (say, add a qualifying question or attribute earlier so that the flow would be less branching).
Make It Clear To The User Why They Need To Perform The Action
Why it’s important:
- To create transparency and build trust;
- To boost conversion rates.
An ideal interface is self-explanatory and needs no microcopy. However, sometimes, we need to convince users to do something for us, especially when it involves providing personal information or interacting with third-party products.
You can use the following formula: “To [get this], do [this] + UI element to make it happen.” For example, “To get your results, provide your email,” followed by an input field.
It’s better to provide the reasoning (“to get your results”) first and then the instructions (“provide your email” ): this way, the guidance is more likely to stick in the user’s memory, smoothly leading to the action. If you reverse the order — giving the instructions first and then the reasoning — the user might forget what they need to do and will have to reread the beginning of the sentence, leading to a less smooth and slightly hectic experience.
Ensure The UI Element Copy Doesn’t Explain How To Interact With This Very Element
Why it’s important:
- If you need to explain how to interact with a UI element, it may be a sign that the interface is not intuitive;
- Risk omitting or not including more important, useful text.
Every now and then, I come across meaningless placeholders or excessive toggle copy that explains how to interact with the field or toggle. The most frequent example is the “Search” placeholder for a search field. Occasionally, I see button labels like “Press to continue.”
Mobile and web interfaces have been around for quite a while, and users understand how to interact with buttons, toggles, and fields. Therefore, explanations such as “click,” “tap,” “enter,” and so on seem excessive in most cases. Perhaps it’s only with a group of checkboxes that you might add something like “Select up to 5.”
You might want to add something more useful. For example, instead of a generic “Search” placeholder for a search field, use specific instances a user might type in. If you’re a fashion marketplace, try placeholders like “oversized hoodies,” “women’s shorts,” and so on. Keep in mind the specifics of your website or app: ensure the placeholder is neither too broad nor too specific, and if a user types something like you’ve provided, their search will be successful.
Stick To The Rule “1 Microcopy Item = 1 Idea”
Why it’s important:
- Not to create extra cognitive load, confusion, or friction;
- To ensure a smooth and simple experience.
Users have short attention spans, scan text instead of reading it thoroughly, and can’t process multiple ideas simultaneously. That’s why it’s crucial to break information down into easily digestible chunks instead of, for example, trying to squeeze all the restrictions into one tooltip.
The golden rule is to provide users only with the information they need at this particular stage to take a specific action or make a decision.
You’ll need to collaborate closely with your designer to ensure the information is distributed over the screen evenly and you don’t overload one design element with a lot of text.
Be Careful With Titles Like “Done,” “Almost There,” “Attention,” And So On
Why it’s important:
- Not to annoy a user;
- To be more straightforward and economical with users’ time;
- Not to overuse their attention;
- Not to provoke anxiety.
Titles, written in bold and larger font sizes, grab users’ attention. Sometimes, titles are the only text users actually read. Titles stick better in their memory, so they must be understandable as a standalone text.
Titles like “One more thing” or “Almost there” might work well if they align with a product’s tone of voice and the flows where they appear are cohesive and can hardly be interrupted. But keep in mind that users might get distracted.
Use this quick check: set your design aside for about 20 minutes, do something else, and then open only the screen for which you’re writing a title. Is what happens on this screen still understandable from the title? Do you easily recall what has or hasn’t happened, what you were doing, and what should be done next?
Don’t Fall Back On Abstract Examples
Why it’s important:
- To make the interface more precise and useful;
- To ease the navigation through the product for a user;
- To reduce cognitive load.
Some products (e.g., any B2B or financial ones) involve many rules and restrictions that must be explained to the user. To make this more understandable, use real-life examples (with specific numbers, dates, and so on) rather than distilling abstract information into a hint, tooltip, or bottom sheet.
It’s better to provide explanations using real-life examples that users can relate to. Check with engineers if it’s possible to get specific data for each user and add variables and conditions to show every user the most relevant microcopy. For example, instead of saying, “Your deposit limit is $1,000 per calendar month,” you could say, “Until Jan 31, you can deposit $400 more.” This relieves the user of unnecessary work, such as figuring out the start date of the calendar month in their case and calculating the remaining amount.
Try To Avoid Negatives
Why it’s important:
- Not to increase cognitive load;
- To prevent friction.
As a rule of thumb, it’s recommended to avoid double negatives, such as “Do not unfollow.” However, I’d go further and advise avoiding single negatives as well. The issue is that to decipher such a message, a user has to perform an excessive logical operation: first eliminating the negation, then trying to understand the gist.
For example, when listing requirements for a username, saying “Don’t use special characters, spaces, or symbols” forces a user to speculate (“If this is not allowed, then the opposite is allowed, which must be…”). It can take additional time to figure out what falls under “special characters.” To simplify the task for the user, opt for something like “Use only numbers and letters.”
Moreover, a user can easily overlook the “not” part and misread the message.
Another aspect worth noting is that negation often seems like a restriction or prohibition, which nobody likes. In some cases, especially in finance, all those *don’t*s might be perceived with suspicion rather than as precaution.
Express Action With Verbs, Not Nouns
Why it’s important:
- To avoid wordiness;
- To make text easily digestible.
When describing an action, use a verb, not a noun. Nouns that convey the meaning of verbs make texts harder to read and give off a legalistic vibe.
Here are some sure signs you need to paraphrase your text for brevity and simplicity:
- Forms of “be” as the main verbs;
- Noun phrases with “make” (e.g., “make a payment/purchase/deposit”);
- Nouns ending in -tion, -sion, -ment, -ance, -ency (e.g., cancellation);
- Phrases with “of” (e.g., provision of services);
- Phrases with “process” (e.g., withdrawal process).
Make Sure You Use Only One Term For Each Entity
Why it’s important: Not to create extra cognitive load, confusion, and anxiety.
Ensure you use the same term for the same object or action throughout the entire app. For example, instead of using “account” and “profile” interchangeably, choose one and stick to it to avoid confusing your users.
The more complicated and/or regulated your product is, the more vital it is to choose precise wording and ensure it aligns with legal terms, the wording users see in the help center, and communication with support agents.
Less “Oopsies” In Error Messages
Why it’s important:
- Not to annoy a user;
- To save space for more important information.
At first glance, “Oops” may seem sweet and informal (yet with an apologetic touch) and might be expected to decrease tension. However, in the case of repetitive or serious errors, the effect will be quite the opposite.
Use “Oops” and similar words only if you’re sure it suits your brand’s tone of voice and you can finesse it.
As a rule of thumb, good error messages explain what has happened or is happening, why (if we know the reason), and what the user should do. Additionally, include any sensitive information related to the process or flow where the error appears. For example, if an error occurs during the payment process, provide users with information concerning their money.
No Excessive Politeness
Why it’s important: Not to waste precious space on less critical information.
I’m not suggesting we remove every single “please” from the microcopy. However, when it comes to interfaces, our priority is to convey meaning clearly and concisely and explain to users what to do next and why. Often, if you start your microcopy with “please,” you won’t have enough space to convey the essence of your message. Users will appreciate clear guidelines to perform the desired action more than a polite message they struggle to follow.
Remove Tech Jargon
Why it’s important:
- To make the interface understandable for a broad audience;
- To avoid confusion and ensure a frictionless experience.
As tech specialists, we’re often subject to the curse of knowledge, and despite our efforts to prioritize users, tech jargon can sneak into our interface copy. Especially if our product targets a wider audience, users may not be tech-savvy enough to understand terms like “icon.”
To ensure your interface doesn’t overwhelm users with professional jargon, a quick and effective method is to show the interface to individuals outside your product group. If that’s not feasible, here’s how to identify jargon: it’s the terminology you use in daily meetings among yourselves or in Jira task titles (e.g., authorization, authentication, and so on), or abbreviations (e.g., OTP code, KYC process, AML rules, and so on).
Ensure That Empty State Messages Don’t Leave Users Frustrated
Why it’s important:
- For onboarding and navigation;
- To increase discoverability of particular features;
- To promote or boost the use of the product;
- To reduce cognitive load and anxiety about the next steps.
Quite often, a good empty state message is a self-destructing one, i.e. one that helps a user to get rid of this emptiness. An empty state message shouldn’t just state “there’s nothing here” — that’s obvious and therefore unnecessary. Instead, it should provide users with a way out, smoothly guiding them into using the product or a specific feature. A well-crafted empty message can even boost conversions.
Of course, there are exceptions, for example, in a reactive interface like a CRM system for a restaurant displaying the status of orders to workers. If there are no orders in progress and, therefore, no corresponding empty state message, you can’t nudge or motivate restaurant workers to create new orders themselves.
Place All Important Information At The Beginning
Why it’s important:
- To keep the user focused;
- Not to overload a user with info;
- Avoid information loss due to fading or cropping.
As mentioned earlier, users have short attention spans and often don’t want to focus on the texts they read, especially microcopy. Therefore, ensure you place all necessary information at the beginning of your text. Omit lead-ins, introductory words, and so on. Save less vital details for later in the text.
Ensure Title And Buttons Are Understandable Without Body Text
Why it’s important:
- For clarity;
- To overcome the serial position effect;
- To make sure the interface, the flow, and the next steps are understandable for a user even if they scan the text instead of reading.
There’s a phenomenon called the serial position effect: people tend to remember information better if it’s at the beginning or end of a text or sentence, often overlooking the middle part. When it comes to UX/UI design, this effect is reinforced by the visual hierarchy, which includes the bigger font size of the title and the accentuated buttons. What’s more, the body text is often longer, which puts it at risk of being missed. Since users tend to scan rather than read, ensure your title and buttons make sense even without the body text.
Wrapping up
Trying to find the balance between providing a user with all the necessary explanations, warnings, and reasonings on one hand and keeping the UI intuitive and frictionless on the other hand is a tricky task.
You can facilitate the process of creating microcopy with the help of ChatGPT and AI-based Figma plugins such as Writer or Grammarly. But beware of the limitations these tools have as of now.
For instance, creating a prompt that includes all the necessary details and contexts can take longer than actually writing a title or a label on your own. Grammarly is a nice tool to check the text for typos and mistakes, but when it comes to microcopy, its suggestions might be a bit inaccurate or confusing: you might want to, say, omit articles for brevity or use elliptical sentences, and Grammarly will identify it as a mistake.
You’ll still need a human eye to evaluate the microcopy &mdahs; and I hope this checklist will come in handy.
Microcopy Checklist
General
✅ Microcopy is role-playable (titles, body text, tooltips, etc., are your “phrases”; button labels, input fields, toggles, menu items, etc. are the user’s “phrases”).
Information presentation & structure
✅ The user has the exact amount of information they need right now to perform an action — not less, not more.
✅ Important information is placed at the beginning of the text.
✅ It’s clear to the user why they need to perform the action.
✅ Everything related to sensitive topics is always visible and static and doesn’t require actions from a user (e.g., not hidden in tooltips).
✅ You provide a user with specific information rather than generic examples.
✅ 1 microcopy item = 1 idea.
✅ 1 entity = 1 term.
✅ Empty state messages provide users with guidelines on what to do (when possible and appropriate).
Style
✅ No tech jargon.
✅ No excessive politeness, esp. at the expense of meaning.
✅ Avoid or reduce the use of “not,” “un-,” and other negatives.
✅ Actions are expressed with verbs, not nouns.
Syntax
✅ UI element copy doesn’t explain how to interact with this very element.
✅ Button label accurately reflects what happens next.
✅ Fewer titles like “done,” “almost there,” and “attention.”
✅ “Oopsies” in error messages are not frequent and align well with the brand’s tone of voice.
✅ Title and buttons are understandable without body text.
(yk)
Introduction to FrankenPHP
FrankenPHP is a new PHP runtime designed to modernize PHP architecture. It is built on top of Caddy, and it includes Caddy’s built-in features such as automatic SSL, native support for HTTP3, and Early Hints. It also supports compression methods like Gzip, Brotli, and Zstd. […]
CodingFrankenPHP is a new PHP runtime designed to modernize PHP architecture. It is built on top of Caddy, and it includes Caddy’s built-in features such as automatic SSL, native support for HTTP3, and Early Hints. It also supports compression methods like Gzip, Brotli, and Zstd. Additionally, it features a built-in Mercure hub, enabling real-time push events without the need for additional libraries or SDKs.
With all these features, FrankenPHP promises faster performance out-of-the-box, simpler configuration, and an improved Developer Experience (DX) compared to traditional PHP setups like PHP-FPM.
Here is how it compares:
| Feature | FrankenPHP | PHP-FPM |
|---|---|---|
| Performance | Great performance with worker mode and direct communication with the web server, reducing latency. | Good performance, but it requires FastCGI communication which may introduce some overhead. |
| Scalability | Excellent scalability. It can be compiled into a single binary, making it easy to run on serverless architectures. | Good scalability, but often requires manual tuning of process pools on both the PHP-FPM and the web server side (usually Nginx). |
| Complexity | Generally simple with minimal configuration overhead, thanks to Caddy’s configuration. | Somewhat complex, involving separate configurations for PHP-FPM and the web server (usually Nginx). |
Getting Started
Running FrankenPHP requires Docker. It is pre-packaged in a single Docker image, so you don’t need to install PHP binaries and modules yourself. Once you have Docker installed, you need to create the index.php file, which will serve as the homepage.
In this example, let’s keep it simple. I will just print the PHP info table.
<?php
phpinfo();
You can now run the following Docker command to start the site:
docker run -v $PWD:/app/public -p 80:80 -p 443:443 -p 443:443/udp dunglas/frankenphp
This command mounts the current directory to the /app/public directory in the Docker container and maps ports 80 and 443 from the container to the host machine, as well as 443/udp to enable HTTP3.
Caddy also generates SSL certificates and loads the site over HTTPS. However, your browser won’t recognize the SSL certificate for localhost, so you will receive an error when you load the site.
There are a few ways we can create a workaround to let HTTPS load on localhost. The easiest and quickest method that works in different scenarios is to enable the flag in Chrome at chrome://flags/#allow-insecure-localhost. Restart Chrome, and then reload the page.
Now, your localhost runs on the FrankenPHP server API. If you inspect the response in Chrome, you’ll see that it’s compressed with zstd and served through HTTP3.
It’s impressive that we can have it running with just a single command.
Running a Framework
FrankenPHP is not limited to just running a simple PHP file. It is compatible and can run a full-fledged PHP framework such as Symfony, Laravel, or any other PHP framework. The only thing you need to do is mount the framework directory to the /app/public directory in the Docker container. For example, to run a Laravel application, you can run the following command:
docker run -v $PWD:/app -p 80:80 -p 443:443 -p 443:443/udp dunglas/frankenphp
It’s that simple. FrankenPHP will automatically detect the files and serve the Laravel application.
Wrapping Up
All these features like automatic SSL, HTTP3, and modern compression make developing and running PHP applications much easier and faster. If you’re coming from nginx or Apache, like me, the only thing you need to get used to is the Caddyfile configuration. But once you get accustomed to it, you’ll find it much simpler and more powerful than traditional web server configurations.
I think FrankenPHP is a great choice for modern PHP applications. It’s fast, scalable, and easy to use. I highly recommend it for any PHP developers looking to give it a try.
The post Introduction to FrankenPHP appeared first on Hongkiat.
