Archive for the ‘Others’ Category

How to Build a Nearly Headless WordPress Website

October 18th, 2021 No comments

I believe that a traditional WordPress theme should be able to work as effectively as a static site or a headless web app. The overwhelming majority of WordPress websites are built with a good ol’ fashioned WordPress theme. Most of them even have good caching layers, and dependency optimizations that make these sites run reasonably fast. But as developers, we have accomplished ways to create better results for our websites. Using a headless WordPress has allowed many sites to have faster load speeds, better user interactions, and seamless transitions between pages.

The problem? Maintenance. Let me show you another possibility!

Let’s start by defining what I mean by “Traditional” WordPress, “Headless” WordPress, and then “Nearly Headless” WordPress.

Traditional WordPress websites

Traditionally, a WordPress website is built using PHP to render the HTML markup that is rendered on the page. Each time a link is clicked, the browser sends another request to the server, and PHP renders the HTML markup for the site that was clicked.

This is the method that most sites use. It’s the easiest to maintain, has the least complexity in the tech, and with the right server-side caching tools it can perform fairly well. The issue is, since it is a traditional website, it feels like a traditional website. Transitions, effects, and other stylish, modern features tend to be more difficult to build and maintain in this type of site.


  1. The site is easy to maintain.
  2. The tech is relatively simple.
  3. There is great compatibility with WordPress plugins.


  1. Your site may feel a little dated as society expects app-like experiences in the browser.
  2. JavaScript tends to be a little harder to write and maintain since the site isn’t using a JavaScript framework to control the site’s behavior.
  3. Traditional websites tend to run slower than headless and nearly headless options.

Headless WordPress websites

A headless WordPress website uses modern JavaScript and some kind of server-side RESTful service, such as the WordPress REST API or GraphQL. Instead of building, and rendering the HTML in PHP, the server sends minimal HTML and a big ol’ JavaScript file that can handle rendering any page on the site. This method loads pages much faster, and opens up the opportunity to create really cool transitions between pages, and other interesting things.

No matter how you spin it, most headless WordPress websites require a developer on-hand to make any significant change to the website. Want to install a forms plugin? Sorry, you probably need a developer to set that up. Want to install a new SEO plugin? Nope, going to need a developer to change the app. Wanna use that fancy block? Too bad — you’re going to need a developer first.


  1. The website itself will feel modern, and fast.
  2. It’s easy to integrate with other RESTful services outside of WordPress.
  3. The entire site is built in JavaScript, which makes it easier to build complex websites.


  1. You must re-invent a lot of things that WordPress plugins do out of the box for you.
  2. This set up is difficult to maintain.
  3. Compared to other options, hosting is complex and can get expensive.

See “WordPress and Jamstack” for a deeper comparison of the differences between WordPress and static hosting.

I love the result that headless WordPress can create. I don’t like the maintenance. What I want is a web app that allows me to have fast load speeds, transitions between pages, and an overall app-like feel to my site. But I also want to be able to freely use the plugin ecosystem that made WordPress so popular in the first place. What I want is something headless-ish. Nearly headless.

I couldn’t find anything that fit this description, so I built one. Since then, I have built a handful of sites that use this approach, and have built the JavaScript libraries necessary to make it easier for others to create their own nearly headless WordPress theme.

Introducing Nearly Headless WordPress

Nearly headless is a web development approach to WordPress that gives you many of the app-like benefits that come with a headless approach, as well as the ease of development that comes with using a traditional WordPress theme. It accomplishes this with a small JavaScript app that will handle the routing and render your site much like a headless app, but has a fallback to load the exact same page with a normal WordPress request instead. You can choose which pages load using the fallback method, and can inject logic into either the JavaScript or the PHP to determine if the page should be loaded like this.

You can see this in action on the demo site I built to show off just what this approach can do.

For example, one of the sites implementing this method uses a learning management system called LifterLMS to sell WordPress courses online. This plugin has built-in e-commerce capabilities, and sets up the interface needed to host and place course content behind a paywall. This site uses a lot of LifterLMS’s built-in functionality to work — and a big part of that is the checkout cart. Instead of re-building this entire page to work inside my app, I simply set it to load using the fallback method. Because of this, this page works like any old WordPress theme, and works exactly as intended as a result — all without me re-building anything.


  1. This is easy to maintain, when set-up.
  2. The hosting is as easy as a typical WordPress theme.
  3. The website feels just as modern and fast as a headless website.


  1. You always have to think about two different methods to render your website.
  2. There are limited choices for JavaScript libraries that are effective with this method.
  3. This app is tied very closely to WordPress, so using third party REST APIs is more-difficult than headless.

How it works

For something to be nearly headless, it needs to be able to do several things, including:

  1. load a page using a WordPress request,
  2. load a page using JavaScript,
  3. allow pages to be identical, regardless of how they’re rendered,
  4. provide a way to know when to load a page using JavaScript, or PHP, and
  5. Ensure 100% parity on all routed pages, regardless of if it’s rendered with JavaScript or PHP.

This allows the site to make use of progressive enhancement. Since the page can be viewed with, or without JavaScript, you can use whichever version makes the most sense based on the request that was made. Have a trusted bot crawling your site? Send them the non-JavaScript version to ensure compatibility. Have a checkout page that isn’t working as-expected? Force it to load without the app for now, and maybe fix it later.

To accomplish each of these items, I released an open-source library called Nicholas, which includes a pre-made boilerplate.

Keeping it DRY

The biggest concern I wanted to overcome when building a nearly-headless app is keeping parity between how the page renders in PHP and JavaScript. I did not want to have to build and maintain my markup in two different places — I wanted a single source for as much of the markup as possible. This instantly limited which JavaScript libraries I could realistically use (sorry React!). With some research, and a lot of experimentation, I ended up using AlpineJS. This library kept my code reasonably DRY. There’s parts that absolutely have to be re-written for each one (loops, for example), but most of the significant chunks of markup can be re-used.

A single post template rendered with PHP might look like something like this:

if ( have_posts() ) {
  while ( have_posts() ) {
    if ( is_singular() ) {
      echo nicholas()->templates()->get_template( 'index', 'post', [
        'content' => Nicholas::get_buffer( 'the_content' ),
        'title'   => Nicholas::get_buffer( 'the_title' ),
      ] );

That same post template rendered in JavaScript, using Alpine:

<template x-for="(post, index) in $store.posts" :key="index">
  <?= nicholas()->templates()->get_template( 'index', 'post' ) ?>

Both of them use the same PHP template, so all of the code inside the actual loop is DRY:

$title   = $template->get_param( 'title', '' ); // Get the title that was passed into this template, fallback to empty string.$content = $template->get_param( 'content', '' ); // Get the content passed into this template, fallback to empty string.

<article x-data="theme.Post(index)">
  <!-- This will use the alpine directive to render the title, or if it's in compatibility mode PHP will fill in the title directly -->
  <h1 x-html="title"><?= $title ?></h1>
  <!-- This will use the Alpine directive to render the post content, or if it's in compatibility mode, PHP will fill in the content directly -->
  <div class="content" x-html="content"><?= $content ?></div>

Related: This Alpine.js approach is similar in spirit to the Vue.js approach covered in “How to Build Vue Components in a WordPress Theme” by Jonathan Land.

Detect when a page should run in compatibility mode

“Compatibility mode” allows you to force any request to load without the JavaScript that runs the headless version of the site. When a page is set to load using compatibility mode, the page will be loaded using nothing but PHP, and the app script never gets enqueued. This allows “problem pages” that don’t work as-expected with the app to run without needing to re-write anything.

There are several different ways you can force a page to run in compatibility mode — some require code, and some don’t. Nicholas adds a toggle to any post type that makes it possible to force a post to load in compatibility mode.

Along with this, you can manually add any URL to force it to load in compatibility mode inside the Nicholas settings.

These are a great start, but I’ve found that I can usually detect when a page needs to load in compatibility mode automatically based on what blocks are stored in a post. For example, let’s say you have Ninja Forms installed on your site, and you want to use the validation JavaScript they provide instead of re-making your own. In this case, you would have to force compatibility mode on any page that has a Ninja Form on it. You could manually go through and add each URL as you need them, or you can use a query to get all of the content that has a Ninja Forms block on the page. Something like this:

add_filter( 'nicholas/compatibility_mode_urls', function ( $urls ) {
  // Filter Ninja Forms Blocks
  $filtered_urls = Nicholas::get_urls_for_query( [
    'post_type' => 'any',
    's' => 'wp:ninja-forms/form', // Find Ninja Forms Blocks
  ] );

  return array_merge( $urls, $filtered_urls );
} );

That automatically adds any page with a Ninja Forms block to the list of URLs that will load using compatibility mode. This is just using WP_Query arguments, so you could pass anything you want here to determine what content should be added to the list.

Extending the app

Under the hood, Nicholas uses a lightweight router that can be extended using a middleware pattern much like how an Express app handles middleware. When a clicked page is routed, the system runs through each middleware item, and eventually routes the page. By default, the router does nothing; however, it comes with several pre-made middleware pieces that allows you to assemble the router however you see-fit.

A basic example would look something like this:

// Import WordPress-specific middleware
import {
} from 'nicholas-wp/middlewares'

// Import generic middleware
import {
} from "nicholas-router";

// Do these actions, in this order, when a page is routed.
  // First, validate the URL
  // Validate this page is not an admin page
  // Validate this page doesn't require compatibility mode
  // Then, we Update the Alpine store
  // Maybe fetch comments, if enabled
  // Update the history
  // Maybe update the admin bar

// Set up the router. This also uses a middleware pattern.
  // Setup event listener for clicks

From here, you could extend what happens when a page is routed. Maybe you want to scan the page for code to highlight, or perhaps you want to change the content of the tag to match the newly routed page. Maybe even introduce a caching layer. Regardless of what you need to-do, adding the actions needed is as simple as using addRouteAction or setupRouter.

Next steps

This was a brief overview of some of the key components I used to implement the nearly headless approach. If you’re interested in going deeper, I suggest that you take my course at WP Dev Academy. This course is a step-by-step guide on how to build a nearly headless WordPress website with modern tooling. I also suggest that you check out my nearly headless boilerplate that can help you get started on your own project.

The post How to Build a Nearly Headless WordPress Website appeared first on CSS-Tricks. You can support CSS-Tricks by being an MVP Supporter.

Categories: Designing, Others Tags:

Fighting Your Corner: Assertive SEO in 2021+

October 18th, 2021 No comments

The web industry is beset by competing ideals and goals so that the simplicity of numbers makes sense to us: one is more than zero, two is more than one.

When it comes to any metric, there is an understandable temptation to focus on volume. In some cases, absolute metrics make more sense than others. If your goal is to make money, then $1 is marginally better than $0, and $2 is marginally better than $1.

However, even in ecommerce, some conversions are worth more than others; high-value items or items that open up repeat sales are inherently more valuable in the long term.

SEO (Search Engine Optimization) has traditionally been built around a high-traffic numbers game: if enough people visit your site, then sooner or later, someone will convert. But it is far more effective to attract the right type of visitor, the high-value user that will become a customer or even a brand advocate.

The best content does not guarantee success on Google, and neither does good UX or even Core Web Vitals. Content is no longer king. What works is brand recognition.

SERPs Look Different in 2021+

Traditional SEO strategies would have you pack content with keywords. Use the right keywords, have more keywords than your competitor, and you’ll rank higher. SERPs (Search Engine Results Pages) used to be a league table for keywords.

Unfortunately, it’s simply not that easy any longer, in part because Google has lost its self-confidence.

Even before the recent introduction of dark mode for Google Search, its SERPs had started to look very different. [We tend to focus on Google in these articles because Google is by far the biggest search engine, and whatever direction Google moves in, the industry follows — except for FLoC, that’s going down like a lead balloon on Jupiter.]

Google’s meteoric success has been due to its all-powerful algorithm. Anything you publish online is scrutinized, categorized, and archived by the all-seeing, all-knowing algorithm. We create quality content to appeal to the algorithm. We trust in its fairness, its wisdom…

…all of us except Google, who have seen behind the curtain and found the great and powerful algorithm, may as well be an old man pulling levers and tugging on ropes.

Content Is President

Google has never been coy about the inadequacies of the algorithm. Backlinks have been one of the most significant ranking factors of the algorithm for years because a backlink is a human confirmation of quality. A backlink validates the algorithm’s hypothesis that content is worth linking to.

One hundred words or so of keyword dense text requires less processing and has fewer outliers, and so is relatively simple for an algorithm to assess. And yet content of this kind performs poorly on Google.

The reason is simple: human beings don’t want thin content. We want rich, high-quality content. Thin content is unlikely to be validated by a human.

The key to ranking well is to create content to which many people want to link. Not only does this drive traffic, but it validates the page for Google’s algorithm.

There Can Be Only One

One of the key motivating factors in the recent changes to search has been the evolution of technology.

Siri, Bixby, and all manner of cyber-butler are queueing up to answer your question with a single, authoritative statement. Suddenly, top-ten on Google is a lot less desirable because it’s only the top answer that is returned.

Google, and other search engines, cannot afford to rely on the all-seeing, all-knowing algorithm because the all-powerful algorithm is just an educated guess. It’s a very good educated guess, but it’s an educated guess nonetheless.

Until now, an educated guess was sufficient because if the top result were incorrect, something in the top ten would work. But when it’s a single returned result, what search engines need is certainty.

The Single Source of Truth

As part of the push towards a single, correct answer, Google introduced knowledge panels. These are panels within search results that present Google’s top answer to any given question.

Go ahead and search for “Black Widow” and you’ll see a knowledge panel at the top of the results hierarchy. Many searchers will never get beyond this.

Knowledge panels are controversial because Google is deferring to a third authority on the subject — in the case of Black Widow, Google is deferring to Marvel Studios. If someone at Marvel decided to redefine Black Widow from action-adventure to romantic comedy, Google would respect that [bizarre] decision and update the knowledge panel accordingly.

Whether we approve of the move towards single results, knowledge panels, and whatever else develops in the next few years, it’s a moot point. It’s happening. Most of us don’t have the pull of Marvel Studios. So the question is, how do we adapt to this future and become the authority within our niche.

Making Use of sameAs

One of the most significant developments in recent years has been structured data. Structured data is essentially metadata that tells search engines how to interpret content.

Using structured data, you can specify whether content refers to a product, a person, an organization, or many other possible categories. Structured data allows a search engine to understand the difference between Tom Ford, the designer, Tom Ford, the corporation, and Tom Ford, the perfume.

Most structured data extends the generic “thing”. And thing contains a valuable property: sameAs.

sameAs is used to provide a reference to other channels for the same “thing”. In the case of an organization, that means your Facebook page, your Twitter profile, your YouTube channel, and anything else you can think of.

Implementing sameAs provides corroboration of your brand presence. In effect, it’s backlinking to yourself and providing the type of third-party validation Google needs to promote you up the rankings.

Be a Brand

Google prefers established brands because people are more likely to trust them, and therefore consider the result that Google returned as high-quality. They will, in turn, come back to Google the next time they need something, and Google’s business model survives another day.

Google’s results are skewed towards brands, so the best strategy is to act like a brand.

Brands tend to be highly localized entities that dominate a small sector. There’s no benefit to spreading out keywords in the hope of catching a lot of traffic. Instead, identify the area that you are an expert in, then focus your content there.

Develop a presence on social media, but don’t sign up for every service available unless you have the time to maintain them properly; a suspended or lapsed account doesn’t corroborate your value.

Big Fish, Flexible Pond

There’s a pop-psychology question that asks whether you would prefer to be a big fish in a small pond or a small fish in a big pond. The direction that search is moving the correct answer is “Big fish, small pond”.

The problem with metaphors is that they carry irrelevant limitations with them. In that question, we assume that there is the choice of two ponds, both a fixed size. There is no reason the pond cannot be flexible and grow with you as you increase in size.

What matters from an SEO point of view is that you dominate your niche. You must become the single source of truth, the number one search result. If you find that you aren’t number one, then instead of competing for that top spot, reduce your niche until you are the number one authority in your niche.

Be the single source of truth that Google defers to, and the all-powerful algorithm can clamber into its balloon and float away.


The post Fighting Your Corner: Assertive SEO in 2021+ first appeared on Webdesigner Depot.

Categories: Designing, Others Tags:

Solving CLS Issues In A Next.js-Powered E-Commerce Website (Case Study)

October 18th, 2021 No comments

Fairprice is one of the largest online grocery stores in Singapore. We are continuously looking out for areas of opportunities to improve the user’s online shopping experience. Performance is one of the core aspects to ensure our users are having a delightful user experience irrespective of their devices or network connection.

There are many key performance indicators (KPI) that measure different points during the lifecycle of the web page (such as TTFB, domInteractiveand onload), but these metrics don’t reflect how the end-user experiences the page.

We wanted to use a few KPIs which correspond closely to the actual experience of the end-users so we know that if any of those KPIs are not performing well, then it will be directly impacting the end-user experience. We found out user-centric performance metrics to be the perfect fit for this purpose.

There are many user-centric performance metrics to measure different points in a page’s life cycle such as FCP, LCP, FID, CLS, and so on. For this case study, we are mainly going to focus on CLS.

CLS measures the total score of all unexpected layout shifts happening between when the page starts loading and till it is unloaded.

Therefore having a low CLS value for a page ensures there are no random layout shifts causing user frustration. Barry Pollard has written an excellent in-depth article about CLS.

How We Discovered CLS Issue In Our Product Page

We use Lighthouse and WebPagetest as our synthetic testing tools for performance to measure CLS. We also use the web-vitals library to measure CLS for real users. Apart from that, we check the Google Search Console Core Web Vitals Report section to get an idea of any potential CLS issues in any of our pages. While exploring the report section, we found many URLs from the product detail page had more than 0.1 CLS value hinting there is some major layout shift event happening there.

Debugging CLS Issue Using Different Tools

Now that we know that there is a CLS issue on the product detail page, the next step was to identify which element was causing it. At first, we decided to run some tests using synthetic testing tools.

So we ran the lighthouse to check if it could find any element which could be triggering a major layout shift, it reported CLS to .004 which is quite low.

The Lighthouse report page has a diagnostic section. That also did not show any element causing a high CLS value.

Then we ran WebpageTest and decided to check the filmstrip view:

We find this feature very helpful since we can find out which element at which point in time caused the layout to shift. But when we run the test to see if any layout shifts are highlighted, there wasn’t anything contributing to the huge LCS:

The quirk with CLS is that it records individual layout shift scores during the entire lifespan of the page and adds them.

Note: How CLS is measured has been changed since June 2021.

Since Lighthouse and WebpageTest couldn’t detect any element that triggered a major layout shift which means it was happening after the initial page load possibly due to some user action. So we decided to use Web Vitals Google Chrome extension since it can record CLS on a page while the user is interacting with it. After performing different actions we found the layout shift score is getting increased when the user uses the image magnify feature.

I have also created a PR to the original repo so that other developers using this library can get rid of the CLS issue.

The Impact Of The Change

After the code was deployed to production, the CLS was fixed on the product details page and the number of pages impacted with CLS was reduced by 98%:

Since we used transform, it also helped to make the image magnify a smoother experience to the users.

Note: Paul Irish has written an excellent article on this topic.

Other Key Changes We Made For CLS

There are also some other issues we faced through many pages in our website which contribute to CLS. Let’s go through those elements and components and see how we tried to mitigate layout shifts arising from them.

  • Web-fonts:
    We have noticed that late loading of fonts causes user frustrations since the content flashes and it also causes some amount of layout shifts. To minimize this we have done few changes:

    • We have self-hosted the fonts instead of loading from 3rd party CDN.
    • We preload the fonts.
    • We use font-display optional.
  • Images:
    Missing height or width value in the image causes the element after the image to shift once the image is loaded. This ends up becoming a major contributor to CLS. Since we are using Next.js, we took advantage of the built-in image component called next/images. This component incorporates several image-related best practices. It is built on top of HTML tag and can help to improve LCP and CLS. I highly recommend reading this RFC to find out the key features and advantages of using it.

  • Infinite Scroll:
    On our website, product listing pages have infinite scrolling. So initially, when users scroll to the bottom of the page they see a footer for a fraction of seconds before the next set of data is loaded, this causes layout shifts. To solve this we took few steps:

    • We call the API to load data even before the user reaches the absolute bottom of the list.
    • We have reserved enough space for the loading state and we show product skeletons during the loading status. So now when the user scrolls, they don’t see the footer for a fraction of seconds while the products are getting loaded.

Addy Osmani has written a detailed article on this approach which I highly recommend checking.

Key Takeaways

  • While Lighthouse and WebpageTest help to discover performance issues happening till page load, they can’t detect performance issues after page load.
  • Web Vitals extensions can detect CLS changes triggered by user interactions so if a page has a high CLS value but Lighthouse or WebpageTest reports low CLS then the Web Vitals extension can help to pinpoint the issue.
  • Google Search Console data is based on real users’ data so that also can point to potential perf issues happening at any point in the life cycle of a page. Once an issue is detected and fixed, checking the report section again can help verify the effectiveness of the performance fix. The changes are reflected within days in the web vitals report section.

Final Thoughts

While CLS issues are comparatively harder to debug, using a combination of different tools till page load (Lighthouse, WebPageTest) and Web Vitals extension (after page load) can help us pinpoint the issue. It is also one of the metrics which is going through lots of active development to cover a wide range of scenarios and this means that how it is measured is going to be changed in the future. We are following to know about any upcoming changes.

As for us, we are continuously working to improve other Core Web Vitals too. Recently, we have implemented responsive image preload and started serving images in WebP format which helped us to reduce 75% of image payload, reduce LCP by 62%, and Speed Index by 24%. You can read more details of optimization for improving LCP and Speed Index or follow our engineering blog to know about other exciting work we are doing.

We would like to thank Alex Castle for helping us debug the CLS issue on the product page and solve the quirks in the next/images implementation.

Categories: Others Tags:

Popular Design News of the Week: October 11, 2021 – October 17, 2021

October 17th, 2021 No comments

Every day design fans submit incredible industry stories to our sister-site, Webdesigner News. Our colleagues sift through it, selecting the very best stories from the design, UX, tech, and development worlds and posting them live on the site.

The best way to keep up with the most important stories for web professionals is to subscribe to Webdesigner News or check out the site regularly. However, in case you missed a day this week, here’s a handy compilation of the top curated stories from the last seven days. Enjoy!

Exciting New Tools for Designers, October 2021

Sprinted – Making You the Most Productive You

11 Must-Follow Web Design Blogs

12 Modern Logos for Inspiration in 2021

Grafix – A Free Online Image Editor

Huetone: Make Colors Accessible

Doom Rendered Via Checkboxes

How to Define a UX Research Approach

Esbuild – An Extremely Fast JavaScript Bundler

It’s Time for Designers to Shift their Obsession with User Experience to User Safety


The post Popular Design News of the Week: October 11, 2021 – October 17, 2021 first appeared on Webdesigner Depot.

Categories: Designing, Others Tags:

A Simple But Effective Mental Health Routine For Programmers

October 16th, 2021 No comments

After working on a coding project for a good couple of hours, many developers like myself tend to hit a wall. The level of creativity goes down, and we feel extreme mental exhaustion (especially if we have been working for more than three hours straight). We can’t help but want a fairly long break from our computers or working (desks) before we can continue with our work.

However, when we have a deadline to meet, we usually brace ourselves and keep going. At times, doing this works because we tap into our deeply hidden mental energy, but also, there are other times when it simply doesn’t work. Our brains go on strike until their demand is met. Which demand, you ask? A long and well-deserved break to refresh and reset.

If we decide to deny or ignore this demand consistently, sooner or later we’ll find that our overall rate of productivity goes down for a good deal of time. We also run the risk of failing at almost everything — including our personal lives.

Let’s take a good look at how we can establish an effective routine that will help ourselves bring benefits work-wise and health-wise in the long term.

Why Having A Routine Is Important

Generally, having a routine we follow has been found to have its own benefits. A study published by The Lancet30139-1/fulltext) concluded that people who have a stable daytime routine tend to have a better cognitive function, restful sleep, emotional stability, and improved overall well-being due to maintaining a good circadian rhythm (the natural cycles of life, like the sleep-wake cycle).

Another study published by Sage Journals showed that those who follow a daily routine tend to feel life is more meaningful for them than those who do not. Having a planned list of activities for the day and ensuring we do every activity when we are supposed to allow us to be less stressed and feel more fulfilled. On top of that, doing everything in our routine gives us a sense of accomplishment and purpose, and adds value to our lives. It also helps ease the tension that comes with the regular demands of life and the hecticness of some of the tough mathematical calculations and creativity-based activities we get engaged in as programmers.

Moreover, it helps us relax and refresh our brains after a long period of work. Now let’s take a look at the actual mental health routine.

The Simple Mental Health Routine For Developers

Personally, my mental health routine has allowed me to be more productive, break through the mental and physical limitations at work and be able to strike a good balance of my work, family and personal life.

Some of the techniques I have used that have proven to be effective are:

  • Resting awareness,
  • Meditation,
  • Mindfulness,
  • Reflection,
  • Body scanning,
  • Visualization,
  • Note-taking,
  • Mindful programming.

The last one is the meat of my routine. Here, I go about my programming tasks as usual but I try to remain aware of myself as I do it. If you would like to have a look at my personal mental health routine in detail where I go in-depth about each practice and how I work with it to better myself and my programming skills, I encourage you to try it out yourself.

Some of the benefits I have seen from the routine are as follows:

Reducing Momentary Negative Effect

For the most part, coding can be quite intimidating and disappointing for a beginner or even a well-versed developer. When we write code with all our hearts — hoping that we got everything right — and then find out that some areas of our code are not working and we can’t seem to figure out where exactly the problem is, we can easily become temporarily frustrated pessimists.

During such times, mindfulness can come in handy for us because research has shown that it helps reduce momentary negative effects. By doing mindful movement techniques such as walking meditation and mindful walking, we can increase positive feelings within ourselves and help us keep going.

Boosting Focus And Attention

When I am aware, I often find it less difficult to keep my focus and attention levels high and I am able to keep going without distractions. Scientific research attributes this ability to a brain wave called Alpha Rhythm that regulates information that brings about distraction.

Thinking, Remembering And Processing Information Better

When we are in the present moment, we get to understand things easily and remember them without a lot of hassles. Reasoning and figuring out how we are going to implement certain bits of our code to achieve the desired goal also become effortless over time.

Studies that focus on this particular topic have revealed that this is due to the ability of mindfulness practice to increase the density of the gray matter in the brain — specifically in those areas that are associated with perspective thinking, learning abilities, self-referential processing, and emotional regulation.

Feeling More Stable After Working Long Hours

Have you ever felt overwhelmed to the point where you you have lost control of yourself in terms of peace and calmness? Mindfulness gives us clarity on what we are working on and keeps us peaceful. In the past, I had scenarios where I felt so overwhelmed and disappointed by the constant inability to solve various bugs in my code that made me question why I got into programming in the first place.

As I practiced mindfulness, however, I was able to tell when I was exaggerating issues in my mind and when my thoughts were blowing things out of proportion. With the help of mindfulness techniques such as mindful walking and reflection, we get to see reality as it actually is, and not as we think of it. This changes our perspective for the better.

Regulating Stress And Anxiety

Are you about to miss deadlines and your mind can’t calm down and let you finish up on the remaining tasks in peace? Well, mindful breathing and visualization of your situation allow you to be aware of the stress and anxiety, and better react to them. It helps bring down the high levels of the Cortisol hormone that is linked to stress.

The points above are part of a simple mindfulness-based mental health routine that we can all easily work with as employed developers, freelancers, or as we run our own programming ventures (link to the mental health routine freebie). Implementing some of these would require a few minutes of meditation in the morning and then after that, we remain aware of ourselves and our environment as we go about our work in our typical day.

Getting Started With Your Own Mental Health Routine

In case you feel, individually, like you want to make some more customization to the given mental health routine above, by all means, feel free to do it. At the end of the day, it is about finding a mental health routine that goes well with you and has a positive impact on your work and life as a whole. Your mental health routine should be something that complements what you already have in your life and what you feel is good for you as a uniquely different person.

So don’t feel the pressure to have to stick to something that doesn’t necessarily sit well with you. However, below are some ideas or other mental health improvement strategies that are effective which you can explore.


Yoga is a practice that helps us quiet our minds so as to ground ourselves in unbound consciousness, which is our essential nature. It helps unite the physical, mental, and spiritual aspects of our lives. Some of its benefits include improving memory, learning abilities, social-emotional processing, sensorimotor processing, and many other cognitive functions. This can make a good addition to your routine if these are the benefits you are looking for.

Other Meditation Styles

Other than mindfulness meditation, there are other meditation styles such as focused attention meditation, zen meditation, religious meditation (for various religions), and others that help train our brains on various personal values. You can look at your life and decide which areas you fall short in that affect your programming career and life in general, and go for a meditation practice that helps you with that. For instance, if you struggle to remain focused, you can work with focused attention meditation to sharpen your focus.


Funny as it may sound, sleep is a really good technique to refresh our minds and bodies. Studies show that it helps with improving the communication between nerve cells. On top of the mindfulness-based practices I work with, sleep is another one of my go-to techniques when I feel I need a total refreshing of my mind.

When you feel confused or overworked, leave your workplace and find yourself a place to lay down and shut down for a few minutes (if that won’t get you fired). However, don’t get into the habit of sleeping, or that will become counter-productive. I always recommend sleeping as the last resort.

Plan Ahead

One of the things that lead to confusion is a lack of planning. If you start off in many directions, you are sure to lose and come out more confused than you started. Programming requires a lot of mental planning before we get to execute it physically and research has linked this kind of planning to project success, not only in programming but also in other areas of our lives.

What I normally do isgain a good understanding of the entire project I am working on, the areas that I am supposed to work on, what is needed in those areas, and then I break down the work into small steps in my to-do list. Everytime I finish a task, I tick it off my list. This helps me make consistent progress and achieve the goal much faster.

Physical Exercise

While physical fitness is good for the body, it has also been found to have a positive effect on the brain. It reduces anxiety, depression, and negative moods. So, whenever you feel anxious or moody, just get into some exercises before getting back to work and you will most likely love the results.

Look For A Developer Friend

Sharing your problems with someone who understands the gravity of the issues, and who can also help you solve them, is among the most valuable things in life. Look for a programming buddy or team you can easily get along with and become work and life buddies.

Hold each other accountable, help each other through your projects, and consult each other when you need genuine feedback and constructive criticism. This makes for peace of mind, enjoyment, more productivity and satisfaction with your career.

Change Your Working Environment (If You Can)

This works well if you are a work-from-home developer. Although, it is also possible to change your environment in your workplace if your company has provided alternative sitting areas. Changing your environment can reset your mind and help you through some hurdles you have been struggling to get past. You can choose to change your sitting position, or move to a different corner of your office or working space. These actions might seem small but all have a significant impact.

Get A Breath Of Fresh Air

Exposing yourself to fresh air allows you to get more oxygen to your brain which helps improve the performance of the brain. If you stay in a poorly ventilated room for a long time, you can hurt your brain in the long run. By regularly getting some fresh air, you improve the power of your brain which can, in turn, help you push even further.

Listen To Your Favorite Songs

Different songs have different effects on people. Whenever you feel mentally and physically exhausted, listening to songs that remind you of your dreams, goals, and visions, as you relax, can energize you and make you want to keep going with your work.

Just close your eyes, lean back on your working chair, and listen to those songs as you visualize your goals and the amount of effort needed to get there, and you will notice your energy levels and motivation increase after some time. My personal favorite playlist is the slow independent (indie) songs or a playlist of slow soothing songs or instrumentals.


When trying out any of the techniques mentioned in this article, please ensure that you go for the ones that will blend in with your daily schedule, habits and beliefs as that will make it possible to have a much better experience working with them.

Taking care of our mental health is of utmost importance. We only get to have one brain throughout our lives so we need to do all we can to take good care of it. And the best part is that you don’t need to do much to make that happen. All you have to do is to get started on a mental health routine and stick to it. The first step is by adding the routine to your daily schedule. If the provided mental health routine works fine for you, figure out where you can begin doing mindfulness meditation and then remember to work mindfully.

If you want to spice things up, you can consider the other mental health techniques you like and use them to create your custom mental health routine that best fits your lifestyle. It is entirely up to you.

The key takeaway here is, you should seriously consider working with a routine and it’s even better if you get started with one as early as now if you want to improve your mental health, your work, and your overall well-being for years to come.

Again, if you would like to have a look at my completely detailed mental health routine, feel free to download it here.

So, what technique or daily routine works best for you? I’d love to hear from you in the comments section below!

Categories: Others Tags:

Expandable Sections Within a CSS Grid

October 15th, 2021 No comments
A grid of product cards in a three by two layout. Each card has a placeholder gray image, product name, descriptions, price, and small text.

I love CSS Grid. I love how, with just a few lines of code, we can achieve fully responsive grid layouts, often without any media queries at all. I’m quite comfortable wrangling CSS Grid to produce interesting layouts, while keeping the HTML markup clean and simple.

But recently, I was presented with a unique UI conundrum to solve. Essentially, any given grid cell could have a button that would open up another, larger area that is also part of the grid. But this new larger grid cell needed to be:

  1. right below the cell that opened it, and
  2. full width.

Turns out there is a nice solution to it, and in the spirit of CSS Grid itself, it only involves a couple of lines of code. In this article, I’ll combine three one-line CSS Grid “tricks” to solve this. No JavaScript needed at all.

An explanation of the actual problem I need to solve

Here’s a minimalist UI example of what I needed to do:

This is our actual product card grid, as rendered in our Storybook component library:

Each product card needed a new “quick view” button added such that, when clicked, it would:

  • dynamically “inject” a new full-width card (containing more detailed product information) immediately below the product card that was clicked,
  • without disrupting the existing card grid (i.e. retain the DOM source order and the visual order of the rendered cards in the browser), and
  • still be fully responsive.

Hmmm… was this even possible with our current CSS Grid implementation?

Surely I would need to resort to JavaScript to re-calculate the card positions, and move them around, especially on browser resize? Right?

Google was not my friend. I couldn’t find anything to help me. Even a search of “quick view” implementations only resulted in examples that used modals or overlays to render the injected card. After all, a modal is usually the only choice in situations like this, as it focuses the user on the new content, without needing to disrupt the rest of the page.

I slept on the problem, and ultimately came to a workable solution by combining some of CSS Grid’s most powerful and useful features.

CSS Grid Trick #1

I was already employing the first trick for our default grid system, and the product card grid is a specific instance of that approach. Here’s some (simplified) code:

.grid {
  display: grid;
  gap: 1rem;
  grid-template-columns: repeat(auto-fit, 20rem);

The “secret sauce” in this code is the grid-template-columns: repeat(auto-fit, 20rem); which gives us a grid with columns (20rem wide in this example) that are arranged automatically in the available space, wrapping to the next row when there’s not enough room.

Curious about auto-fit vs auto-fill? Sara Soueidan has written a wonderful explanation of how this works. Sara also explains how you can incorporate minmax() to enable the column widths to “flex” but, for the purposes of this article, I wanted to define fixed column widths for simplicity.

CSS Grid Trick #2

Next, I had to accommodate a new full-width card into the grid:

.fullwidth {
  grid-column: 1 / -1;

This code works because grid-template-columns in trick #1 creates an “explicit” grid, so it’s possible to define start and end columns for the .fullwidth card, where 1 / -1 means “start in column 1, and span every column up to the very last one.”

Great. A full-width card injected into the grid. But… now we have gaps above the full-width card.

Two rows of four rectangles. All of the rectangles are light gray and numbered, except one that has a wheat-colored background and another box beneath it containing text, and taking up the full container width.

CSS Grid Trick #3

Filling the gaps — I’ve done this before with a faux-masonry approach:

.grid {
  grid-auto-flow: dense;

That’s it! Required layout achieved.

The grid-auto-flow property controls how the CSS Grid auto-placement algorithm works. In this case, the dense packing algorithm tries to fills in holes earlier in the grid.

  • All our grid columns are the same width. Dense packing also works if the column widths are flexible, for example, by using minmax(20rem, 1f).
  • All our grid “cells” are the same height in each row. This is the default CSS Grid behavior. The grid container implicitly has align-items: stretch causing cells to occupy 100% of the available row height.

The result of all this is that the holes in our grid are filled — and the beautiful part is that the original source order is preserved in the rendered output. This is important from an accessibility perspective.

See MDN for a complete explanation of how CSS Grid auto-placement works.

The complete solution

CodePen Embed Fallback

These three combined tricks provide a simple layout solution that requires very little CSS. No media queries, and no JavaScript needed.

But… we do still need JavaScript?

Yes, we do. But not for any layout calculations. It is purely functional for managing the click events, focus state, injected card display, etc.

For demo purposes in the prototype, the full-width cards have been hard-coded in the HTML in their correct locations in the DOM, and the JavaScript simply toggles their display properties.

In a production environment, however, the injected card would probably be fetched with JavaScript and placed in the correct location. Grid layouts for something like products on an eCommerce site tend to have very heavy DOMs, and we want to avoid unnecessarily bloating the page weight further with lots of additional “hidden” content.

Quick views should be considered as a progressive enhancement, so if JavaScript fails to load, the user is simply taken to the appropriate product details page.

Accessibility considerations

I’m passionate about using correct semantic HTML markup, adding aria- properties when absolutely necessary, and ensuring the UI works with just a keyboard as well as in a screen reader.

So, here’s a rundown of the considerations that went into making this pattern as accessible as possible:

  • The product card grid uses a
    • construct because we’re displaying a list of products. Assistive technologies (e.g. screen readers) will therefore understand that there’s a relationship between the cards, and users will be informed how many items are in the list.
    • The product cards themselves are
      elements, with proper headings, etc.
    • The HTML source order is preserved for the cards when the .fullwidth card is injected, providing a good natural tab order into the injected content, and out again to the next card.
    • The whole card grid is wrapped in an aria-live region so that DOM changes are announced to screen readers.
    • Focus management ensures that the injected card receives keyboard focus, and on closing the card, keyboard focus is returned to the button that originally triggered the card’s visibility.

    Although it isn’t demonstrated in the prototype, these additional enhancements could be added to any production implementation:

    • Ensure the injected card, when focused, has an appropriate label. This could be as simple as having a heading as the first element inside the content.
    • Bind the ESC key to close the injected card.
    • Scroll the browser window so that the injected card is fully visible inside the viewport.

    Wrapping up

    So, what do you think?

    This could be a nice alternative to modals for when we want to reveal additional content, but without hijacking the entire viewport in the process. This might be interesting in other situations as well — think photo captions in an image grid, helper text, etc. It might even be an alternative to some cases where we’d normally reach for


    (as we know those are only best used in certain contexts).

    Anyway, I’m interested in how you might use this, or even how you might approach it differently. Let me know in the comments!

    The post Expandable Sections Within a CSS Grid appeared first on CSS-Tricks. You can support CSS-Tricks by being an MVP Supporter.

Categories: Designing, Others Tags:

7 Simple Ways to Boost Your Website’s CX

October 15th, 2021 No comments

Many markets are saturated with competition; it’s no surprise that customers are expecting top-of-the-line experiences. Businesses must keep up with these ever-changing demands to remain competitive and drive forward.

One way to ensure customers have positive experiences is to take a look at your website. Your website is like your digital headquarters, where customers can browse through products or services, have frequently asked questions answered, and be able to reach you if they need direct support.

Making a site user-friendly and customer-centric will assist businesses while they work to build a loyal customer base. Customer happiness is more important now than ever and has the potential to make or break your business. We all know that happier customers spend more, and delighted customers will always come back for more.

Let’s explore some ways you can level up the customer experience on your website to foster customer loyalty and retention, as well as garner brand advocates for your business.

How Important Is CX?

As a site manager, your goal should be to meet customers’ needs. Creating a website is no simple task but can transform CX (customer experience).

Suppose a customer visits your site only to see a buffering symbol or a lag on their desktop or mobile device. This wouldn’t make for a positive experience, would it?

When customers have to spend extra time navigating your website to find what they’re looking for, it can directly lead to site abandonment, where customers leave the site before browsing. It’s vital to consistently monitor your website metrics to see if abandonment rates impact your overall traffic.

Customers who have enjoyable experiences browsing through your site are more likely to appreciate your brand and strongly consider purchasing whatever offerings you have.

Additionally, positive customer reviews can help your business gain new customers — word-of-mouth marketing is still relevant in 2021’s digital marketing landscape. Earning those 5-star reviews can help other potential customers see that they too could have a positive experience with your brand.

As you can see, CX is just as important as the products or services you offer, so keep that in mind as you set out on the journey to improve your website to advocate for your customer base.

Below, we’ll cover some of the most important elements and features of a strong business site so you can implement them.

Valuable Features to Include on Your Website

The features of your website are the foundation of your business. One of the best parts of building a killer website is that you can get as creative as you’d like with all of the features at your disposal.

Whether you use WordPress or another platform to host your website, you can always explore other paid services or offerings online to bring your site to the next level.

For example, the WooCommerce WordPress extension allows e-commerce sites to improve the overall appearance of their site, add customizations and, generally speaking, create a high-quality e-commerce store.

Below are some examples of elements you should consider incorporating into your web design. Offering these features will surely keep your site visible, relevant, and attractive to all types of customers.

1. Add Personalization

Every type of customer can benefit from a personalized experience, and it helps you turn them into loyal customers.

Personalization is becoming more prevalent in web design, whether it’s including past products they’ve viewed on your landing page or making it simple for them to log in to their account.

Maybe you allow your customers to create a wishlist, just as Amazon does. You could also make personalized deals or recommendations for your customers based on their past purchases or search history. When customers see this level of personalization, it may influence their purchasing decisions and make it simpler for them to order products.

2. Include Compelling and Unique Content

Every professional in the digital marketing space knows that content is king. The companies that include the most compelling content garner the most attention and increase the number of customers who make up their customer base. Here are some examples of what your content should look like:

  • Comprehensive
  • Useful
  • Accurate
  • Visually appealing
  • Helpful
  • A direct answer to a search engine query

By following these descriptions, your content will improve. Whether it’s a blog post or a photo or video, quality content is a driving factor in your user engagement. It helps to support your SEO strategy and will undoubtedly keep customers coming back.

3. Prioritize Speed and Usability

Because technology is an integral part of most people’s lives, customers expect to visit a fast, reliable website. No longer will customers wait patiently for a site to load. The dreaded buffering symbol is a clear indicator that your business is not taking customer experience into account.

It’s critical to create a website that loads quickly and is easy to use. Avoid organizing any tabs in a confusing way. Ensure that your website is visually attractive without overwhelming color schemes or photos that take up too much space.

Go for a more modern, contemporary look that’s easy on the eyes. Customers will appreciate this and will likely spend more time browsing your various website pages.

4. Focus on Navigation

Users should be able to access any page on your website with ease. They shouldn’t have to search for the right drop-down menu or type into the search bar unless they’re searching for a specific product or service.

The majority of users on a site, 70% to be exact, spend most of their time navigating freely without using the search bar. This should tell you how vital good navigation is to your business website. Placing menus on the top of your site is common practice — if you would rather place your drop-down menu somewhere else, make sure you’re putting it in a section where it’s easy to find.

Put yourself in your customers’ shoes. See what types of designs you can incorporate into your site to elevate UX and make browsing simple.

5. Make Sharing Simple

One of the best ways to grow your customer advocates is by leveraging your existing customers. Your customers should be able to easily send your product or service descriptions to their friends and family.

Rather than copying a link, include a share feature. If something on your site is worth sharing with other potential customers, make it easy for them to send it.

Social sharing plays a significant role in digital marketing — it helps to garner organic traffic to your website. You can reach a larger number of people than originally intended, which is the most important benefit to reap by making it easy to share links from your site.

6. Incorporate Chatbots

Offering customer support by using chatbots is something major companies are incorporating into their website designs.

Suppose your customer is trying to complete a purchase but runs into a problem with a coupon they’d like to use. Rather than wait on hold on the phone or for an email in their inbox a few days later, an automated chatbot can step in and assist them.

Chatbots are on the rise, and it’ll be critical for your business to include them on your site. Proactive web actions can increase your site’s conversion rates and improve the overall customer experience.

7. Allow Customer Feedback

It shouldn’t come as a surprise that allowing your customers to share their experience with your brand can help you better understand them and the solutions they’re looking for from you.

Did you know that brands with superior customer service can generate 5.7 times more revenue than their competitors? When you’re in touch with your audience, you’re better able to include features they want and need to have a positive experience. By taking advantage of customer feedback, you can make necessary changes to your site to better serve your customers.

Advocate for Your Customer Base

All of the examples listed above can help elevate your site and improve the overall experience for existing and potential customers. Isn’t that the goal of any business, regardless of industry?

To serve your customers effectively means they’ll feel valued and come back for more. Whether that’s ordering more products or requesting more services, you’ll see the benefits of including the elements we’ve covered in this post.

As a recap, here are some steps you can take to advocate for your loyal customers:

  1. Add personalization
  2. Include unique content
  3. Make your site fast and usable
  4. Provide easy navigation
  5. Allow for easy sharing
  6. Leverage chatbots
  7. Be open to feedback

Overall, customer experience will become more important in the future as customer expectations change. Standing out from your competitors is no longer an option but a necessity. So many markets are struggling to do just that — so if you’re able to offer unique features on your site, it could potentially draw more customers in and drive them to purchase.


Featured image via Unsplash.


The post 7 Simple Ways to Boost Your Website’s CX first appeared on Webdesigner Depot.

Categories: Designing, Others Tags:

Tips And Tricks For Evaluating UX/UI Designers

October 15th, 2021 No comments

When a company’s digital representation lacks a dedicated UX/UI design team, it can be hard to produce something that stands out from the crowd. The best designers and agencies have a touch of magic about them, transforming your company’s goals, customers’ demands, user specifications, and design instruments into a beneficial experience for both users and businesses. It may seem enchanting how well-designed apps or websites can boost your sales, but it takes far more than a handful of fairy dust to make users enjoy their interactions.

The reason we pay so much attention to design (as we do to any other detail in the process of project completion) is that it plays one of the crucial roles in your business success. To get decent ROI in the digital sphere, you need both a great product and a great design. The two are interdependent. If your design is flawless but your service lacks essential features, don’t expect design to cover for them. And vice versa.

Yet, providing your customers with a well-designed digital solution gives them a chance to appreciate your product to its fullest. That happens when your app/website/system is efficient. And memorable. And easy to understand. And reliable. And carefully arranged. And elaborate. And forms an immediate emotional connection with the users. And urges them to come back again. That’s why you need a good UI/UX designer. Or, better yet, a team.

This article is about the essentials of evaluating potential designers and design agencies you wish to hire. Getting this right is more important than ever, for a couple of reasons:

  1. The global pandemic situation has reshaped the way business is conducted, especially online.
  2. Even once COVID-driven economic conditions cease to exist in the (hopefully) near future, outsourcing will remain a better option for many companies, both in terms of financial resources and worldwide talent engagement.

Every selection process starts with understanding how important it is to have an expert who “gets” your end-users, who can collect all the needs, don’ts, wants, shoulds, and must-haves to ensure you communicate with customers fluently. Then, you start wondering HOW to find out if you have chosen the right person for the job.

NB: Following your gut may be helpful in making some business decisions, BUT this is not the case here.

The ultimate goal is to ensure your app/website can provide its users with the most value possible as seamlessly as possible. So, you expect your designer/design agency to be equally as efficient, cutting, and customer-centered in terms of design and UX.

When it comes to the decision-making process, many businesses make the same mistake over and over again. They apply the same methods used to hire entirely different roles, or allow themselves to trust their instincts.

This article exists to prevent those things from happening. Intuition is not the best adviser when selecting or outsourcing a UX/UI designer. The key to successful hiring requires a different strategy: a list of strict requirements and versatile aspects to assess. The latter would help you pass a more objective and qualified verdict on the candidate’s ability to help your company thrive.

Know What YOU Want Before Evaluating A Designer

I don’t want to give you a set of “designer evaluation criteria” straight away, and the reason is this: it’s not the best place to start. Stage one is about identifying what your company needs from a certain digital product. Before selecting a UX/UI designer/design agency, you have to sit down and list all the requirements and deliverables. This will help you understand what qualities you are actually looking for in your future employee.

Where deliverables are concerned, include the ones you may have in both the research and the production phase of your collaboration. The former may require user experience research, user behavior analysis, brand positioning, and market niche analysis. The latter will include prototyping, usability, and interaction design testing, as well as building wireframes and exploring user journeys.

Using such tools is financially effective, helping to reduce your costs of service by 15-20%. Mapping out user journeys in detail helps to track both minor and global issues inherent in your company, as well as analyze your target audience preferences, attitudes, dislikes, and fads. This creates a whole new pool of production and marketing opportunities for your business.

At present, customer satisfaction is certainly a priority. In 2021, it’s not just advisable, but compulsory to invest in customer experience as with high-quality software development available literally anywhere and at different costs, successful interaction with your customer is the real game-changer.

To be more precise in terms of software requirements, try to define:

  • the type of the software itself and the environments where it will be applied;
  • tasks, features, and functions your software should be able to perform;
  • similar apps/websites/platforms that might prompt what you like and what you would or wouldn’t expect to get.

In addition, keep in mind usability and affordability reconciliation as well as checking if you meet both standards. Finally, highlight the project’s scope, define timelines, and prepare all the legal papers to be fully armed before you move on.

Once the actual cooperation begins, you and your designer/design agency will have to adjust, revise, and re-define these deliverables and requirements in a more precise manner. So, why bother now? If this seems either too strenuous or irrelevant at this point, remember this: the more specifications you provide to your potential designing partner, the easier the selection process will appear. And the fewer obstacles you will encounter when you work together.

Skill Sets For Evaluation

The next step is finalizing a list of hard and soft skills you wish your designer to have. This step, if carefully planned, is essential to the success of your project. The main obstacle at this stage is the variety of skills and their importance in the course of project implementation. Thus, we have made a downloadable cheatsheet for you to use in the course of the transparent assessment of:

How or where can you use them efficiently? Through analyzing the designers’ previous projects, asking questions at the interviews, or analyzing test tasks and preliminary proposals. The key focus should be on the level of the necessary skills a potential candidate has. By rating them you can make a data-driven decision and base it on the factual representation of the desired qualities.

UX Processes

To start with, here’s a set of the universal UX processes crucial to the successful completion of any design-based project whether or not it is carried out by a remote-work team.

To make your evaluation more accurate, here’s a brief explanation of the processes themselves, reasons why they are necessary, and tips on how to check them. You can use this table to mark the level of their excellence in your potential candidate/agency.

Process What to evaluate Why is it important How to assess
User research Understanding the needs, emotions, perception, and experience of the end-users. Examine target audiences in detail (their age, background, qualifications, interests, possible disability issues etc.) Minimizes the risk of designing the wrong product for the wrong people. Ask what research methods they use and how they affect the final outcome.
Information architecture Presenting information efficiently for users, anticipating their future actions to make navigation through apps and websites easy. This makes users’ interactions with your digital product easy and enjoyable. Check the designer’s previous works to see how the parts fit together. Examine how relevant or compatible they are.
Visual design Using visual elements (fonts, color, background, size, etc) through contrast, proximity, or repetition to convey the functionality of a particular page. Allows you to accentuate and prioritize tasks and messages. Opt for designers you admire, respect, trust, and feel they take into consideration your thoughts on the visual design as well as guide you since it is not a rare occasion that what you want as a client does not always work best for the end-customer.
Prototyping Creating a concept to make adjustments and receive feedback from experts involved. Testing the elements of a digital product before it is finalized is essential, giving you examples of how the app/website will work and look. Ask the designers if their clients have access to a clickable prototype.
Usability evaluation Testing the product to make sure the maximum level of understanding has been reached. Allows you to identify any failures or shortcomings and improve them. Ask designers for examples of how they test their products to check they fit the end-users.
Interaction design Designing how the end-product may feel, look, and interact with the customer. Creates a feedback loop for how beneficial or wanted different features may be to the end-user. Examine previous works and see if the design makes sense and behaves in the expected way.

Bear in mind that although it seems rather optional for the UX/UI designer to master development skills, they appear to be quite handy when it comes to a holistic approach. It is advisable for your designer team to have at least basic knowledge of HTML/CSS and understand how front-end/code/styles work, as well as to be able to use the console and make any adjustments if necessary. All this helps ensure the designing process runs smoothly without rough interruptions, missing significant points, or misunderstanding between the development and the design teams.

These skills may seem purely technical. In fact, they are first and foremost focused on creating a user-oriented digital solution driven by understanding. In terms of its value for your company, according to recent statistics, the top 10 most empathetic companies managed to increase their value more than twice. Surprisingly, in the goal-oriented and pragmatic world of the 21st century, empathy appears to be in high demand. No wonder involving emotional impact into your business activities contributes to enhanced employee relations, higher productivity, and, finally, more revenue. Creating an emphatic environment in which company culture and values, leadership, ethical issues, and brand representation in the public eye matter means investing in your future as a viable and prospective manager.

To sum up, first, you study the processes mentioned above and examine how they are represented in the designer’s works and vision. Next, you check if their qualities correspond to the project requirements you have previously defined. If so, you will reach the highest degree of understanding. What we see as the background for successful cooperation with your designer/agency is clearly defined by one of our clients in the following feedback.

Project Skills

The second list examines project management. They turn out to be even more influential when you think of outsourcing services. That is because the efficient functioning of a remote team demands a higher degree of understanding of the following issues.

Skill What to evaluate Why it is important How to assess
Problem setting and strategic thinking If the designer/design agency can identify and prioritize problems. You can’t fix problems that haven’t been spotted. An eye for them allows you to be proactive in finding solutions. Ask if certain “must-do” issues are valid or not. The experiences they have will show how versatile their vision is.
Systematic approach Whether the candidate understands how products should both meet a need and fit into the user’s life. All the pieces need to fit together for a product to excel. Having a front-to-back outlook helps make that possible. Evaluate their attention to details as well as the bigger picture. Do they connect smoothly?
Innovation, idea generation, and creativity What the designer/design agency considers creative or innovative in their previous works and how they see your project implementation. Processes are important, but so too is lateral thinking. You need to know they can think outside the box while still incorporating your vision. Designers should explain their ideas and solutions in a “why-what for-so what” mode to help you understand the validity of our design decisions.
Proactivity How the designer (or a team leader) initiates ideas, motivates workers, coordinates the remote team, and interacts with your in-house employees. A healthy working culture leads to better work (and happier people). You want those who collaborate, motivate, and inspire. Keep a close eye on whether your approaches towards work management are compatible enough. Otherwise you may get an opponent rather than a partner.
Experience If the designer/design agency has enough experience both in UX/UI design and the area of your interest. As in any line of work, you want people who know what they’re doing, who you trust to bring something to the table you can’t. The indicators for this skill are not the number of years or projects completed but the actual digital solutions produced. Think quality, not quantity. A talented, inexperienced team can still offer great solutions.

Good UX/UI designers look for a special approach towards every client and audience, as well as the solution to the task. They never explore just one path but study a number of options that may make your users’ lives easier.

In order to make your judgment as objective as possible, do not forget that you may engage your team for versatile opinions. Also, try assessing the skill sets during interviews by inquiring, discussing, and comparing your visions of the issues.

Personal Qualities

To make outsourcing cooperation both efficient and effective, never underestimate personal qualities. If anything, they could be the decision triggers in the final stage of your evaluation. The following points will help you understand if you wish to work with a certain remote designer/team and if they can bring value to your company.

How or where can you evaluate these criteria efficiently? Through online interviews, team presentations, back-and-forth messaging, and work sessions.

For those who doubt the value of personal qualities, here are some numbers. Forbes points out that companies excelling at user experience have 1.5 times more engaged employees than those who are less customer-focused. Certainly, it is difficult to analyze such requirements as these are not easily translated into revenue numbers. Yet, to stand out from hundreds of competitors, you need to get out of the so-called “commodity trap” with dozens of similar (if not the same) products and services available here and now. Here, customer experience seems to be the only option to the rescue.

So, what customer-oriented skills need to be assessed are as follows.

Skill What to evaluate Why it is important How to assess
Communication The ability to present and explain ideas clearly and concisely, listening to and following conversations. In short, to work in an agile environment. These qualities indicate whether your team will be easy to reach, understand, and exchange feedback with. It is important to adjust to ever-changing requirements, and in a timely manner. If the designer/team can articulate their ideas to you, they can “talk” to your customers and translate your needs into a digital solution.
Collaboration and empathy How they cooperate with other team members; how they deal with conflicts and resolve disagreements; how flexible and open to feedback they are. If they have these traits, they will be able work with all the people involved in the work process, promote their decisions, support users, and make the product correspond to their needs. Empathy is the core ingredient in creating a successful UX design. Remember it is the end-user who will interact and enjoy (or not) the outcome of their work. Will candidates meet those needs?
Cultural contribution They understand, respect, and represent your company’s values. They are passionate about working with you. A good team is capable of inspiring people they work with. If their vision of values is too different from yours, the product will be far from what you expect. As a sign of respect towards a new client, we show our interest by studying the company and its brand values in advance.

Now you are fully equipped with the refined lists of skills and qualities you should pay attention to in your evaluation. Once you study or even edit them to suit your needs and ideas, you are ready for the next stage.

Navigating Interviews

Once you have the game plan for precise evaluation, your next step is the actual face-to-face (or, rather, camera-to-camera) discussion. In order to filter the talent pool efficiently, start the interview prepared. Remote hiring goes far beyond random inquiries about the candidate’s qualities and experience. It requires a structured list of questions, issues, and topics to discuss.

Beware also of possible technical failures like poor internet connection or not preparing relevant data in advance. Assign times and meeting links to all candidates. Be there on time. Such details will help keep the whole process smooth.

What concerns the list of questions you may ask, always think of their content as well as:

  • The number of questions.
    Have enough to allow for substantive discussions while still keeping to the interview window.
  • Giving the proper chance for the candidates to talk themselves.
    This way they wouldn’t feel like they are being interrogated.

The latter is crucial. In our company, we like to provide candidates with the opportunity to give as much input as possible. Examine your potential designer’s speech to see how good they are at explaining their tasks or technical specifications. Our experience shows that the better designers present their vision orally, the more usability they will bring to the product.

Here are several more points that are much more tricky in their essence.

  • Many articles on this topic tell you to ask about the tools and workflow of the designer/agency. However, do not expect to get a clear checklist to validate the right candidate. On the contrary, you should just make sure the tools match the ones your team prefers. While the workflow is examined to see if your approaches are compatible.
  • Ask the designer/team to present a project or product they really enjoyed. This will show how passionate they are about the design in general and working on your project in particular. Your potential employee would be thrilled to give very specific details. Even better, if they explain how this experience might relate to your cooperation.
  • Never underestimate the designer’s questions about your company/project in return. If they are truly interested, they want to know detailed and relevant(!) information on the target audience, main KPIs, business models, testing methods you apply, and much more.

Mistakes To Avoid

Our experience of providing outsourcing services before, during, and hopefully after the COVID-19 era has provided us with a number of insights. Here are some ideas on what to steer clear of in your evaluation.

  • If your budget is big enough, opt for an agency.
    When compared to freelancers, the former will definitely offer more expertise. Once you vote for an all-in-one option, this person should be either in charge of every stage and process or you may get a limited amount of functions performed.
  • Questions you ask are valuable.
    Sensible re-defining or re-stating may be the key to getting the clarity we need. Sometimes, even the source of new discoveries.
  • Look for initiative as well humility.
    The latter is usually presented as one of the most valuable qualities of a UX/UI designer. However, its significance could be exaggerated. In some cases, it is vital for the designer/team to take the initiative in introducing ideas or justifying important decisions.
  • Prioritizing skills is a dead-end approach.
    You need to evaluate all the necessary skills. Yet, a comprehensive vision is the key to success. Rather than focus on many specific traits, evaluate their combination and compatibility as a whole set.
  • Overestimating portfolios is risky.
    The number of projects does not correspond to the level of expertise. At LinkUp Studio, we offer our clients an overview of the cases related to their project and urge them to look at qualitative achievements. The problems we have solved, the insights and solutions we have offered, and how the latter altered one’s business. Such presentations help future work partners see our holistic approach and the value we bring to their ideas.
  • Do not confuse the initial proposal with the in-depth research which comes after you sign up with the agency.
    Some clients wish to get a preliminary analysis of their project. And that makes sense. A commercial offer presents rough project scope and cost estimation. That is justified for both parties in the process of negotiations. However, further analysis (a.k.a. discovery stage) involves a range of experts like business analysts, designers, developers. So, it should not be expected free of charge as a part of your ballpark estimate.

We hope our experience and useful tips uncovered will fully equip you for a conscious designer evaluation. All in all, the keys to making a successful hire are strict criteria to follow a holistic approach towards the assessment process which includes the following stages:

  1. Identify your company’s precise requirements and deliverables.
  2. Make the lists of hard and soft skills your designers should possess as well as rate their importance for a particular project in mind.
  3. Prepare for and conduct interviews to make the right choice.
  4. Enjoy your cooperation.

Choosing the proper UI/UX designer is the key to providing your customers with an excellent user experience through incorporating your company’s aims and your client’s needs into the design process. The latter being efficient, understandable, reliable, emotionally appealing, and properly devised is the very task of a UI/UX designer you are about to start evaluating.

To help you make this process pain- and stress-free, we have developed a cheat sheet to come in handy during the selection and assessment process. You can download it here.

Categories: Others Tags:

Different Degrees of Custom Property Usage

October 14th, 2021 No comments

One way to work with Custom Properties is to think of them as design tokens. Colors, spacings, fonts, and whatnot. You set them at the root of the page and use them throughout your CSS. Very useful, and the classic use case for not only Custom Properties but for preprocessor variables for the last one million years.

Another way to work with Custom Properties, which can be done in addition to the design tokens approach, is to go a lot harder and use them for every major unique styling choice on any given element.

Imagine you have a Card like this (simplified for demonstration sake, of course):

.card {
  background: hsl(200deg 15% 73%);
  border: 4px solid rgb(255 255 255 / 0.5);
  padding: 2rem;
  border-radius: 8px;
.card > h2 {
  margin: 0 0 1rem 0;
  border-bottom: 3px solid rgba(0 0 0 / 0.2);


But then when you inevitably make variations of the card, you’re on your own to override these rulesets. A CSS Custom Property approach can be like:

.card {
  --card-background: hsl(200deg 15% 73%);
  --card-border: 4px solid rgb(255 255 255 / 0.5);
  --card-padding: 2rem;
  --card-border-radius: 8px;
  --card-title-margin: 0 0 1rem 0;
  --card-title-border: 3px solid rgba(0 0 0 / 0.2);

  background: var(--card-background);
  border: var(--card-border);
  padding: var(--card-padding);
  border-radius: var(--card-border-radius);
.card > h2 {
  margin: var(--card-title-margin);
  border-bottom: var(--card-title-border);

A little more verbose, for now, but look what happens when we want to do a variation:

.card-variation {
  --card-background: purple;
  --card-padding-block: 2.5rem;
  --card-title-margin: 0 0 2rem 0;

Here are three clear advantages right off the bat:

  • I’m only changing values that I’ve clearly set up to be changed. My main Card prototype maintains the integrity I want it to keep.
  • I can style children of the variation without having to re-write those selectors correctly.
  • I can now pass in styling overrides from the style attribute in the HTML for quick, one-off variations.
CodePen Embed Fallback

Less verbose with fallbacks

Rather than declaring the Custom Properties at the top and then using them right below, I can do both at the same time like this:

.card {
  background: var(--card-background, hsl(200deg 15% 73%));
  border: var(--card-border, 4px solid rgb(255 255 255 / 0.5));
  padding: var(--card-padding, 2rem);
  border-radius: var(--card-border-radius, 8px);
.card > h2 {
  margin: var(--card-title-margin, 0 0 1rem 0);
  border-bottom: var(--card-title-border, 3px solid rgba(0 0 0 / 0.2));

Now if something like --card-background does happen to get set, it will override the fallback value here. I don’t completely love this, because it means elements above .card can override it. That might be what you want, but it’s not exactly the same as declaring the values at the .card level to begin with. No strong opinions here.

Breaking it up even more

An example here is that you might want to individually control padding.

.card {
  --card-padding-block: 2rem;
  --card-padding-inline: 2rem;
  --card-padding: var(--card-padding-block) var(--card-padding-inline);

  padding: var(--card-padding);

Now a variation can control just a part of the padding if I want:

.card-variation {
  --card-padding-inline: 3rem;

You gotta be careful of the big gotcha though. Meaning if you declare all these at the root, this isn’t going to work, because those nested properties have already been resolved. But so long as it’s first declared on .card, you’ll be fine here.

Too far?

Say you wanted super ultimate control over every part of a value. For example:

html {
  --color-1-h: 200deg;
  --color-1-s: 15%;
  --color-1-l: 73%;
  --color-1-hsl: var(--color-1-h) var(--color-1-s) var(--color-1-l);
  --color-1: hsl(var(--color-1-hsl));

That’s kinda neat, but it’s likely too far. Colors are almost certainly going to be declared at the root and left alone, so the great gotcha is going to make overriding the low-level child properties impossible. Besides, if you have a --color-1, you probably have a 2-9 (or more) as well, which is all well and good because there is far more delicate design magic to a color system than simple mathematical manipulations of color parts.

Deliverable design systems?

There is no doubt that Tailwind has enjoyed a lot of popularity. It uses an atomic approach where a slew of HTML classes control one property each. I’d argue some of that popularity is driven by the fact that if you choose from these pre-configured classes, that the design ends up fairly nice. You can’t go off the rails. You’re choosing from a limited selection of values that have been designed to look good.

I wouldn’t go as far as to say that a Custom Properties heavy-based approach to styling is exactly the same. For example, you’ll still need to think of a class name abstraction rather than apply styling directly to the HTML element. But, it might enjoy some of the same constraints/limitations that make Tailwind and other atomic class approaches desirable. If you can only pick from a pre-defined set of --spacing-x values, --color-x values, and --font-x values, you might achieve a more cohesive design than you would have otherwise.

Personally, I’ve found inching toward a design system that is more heavily based on Custom Properties feels good — if nothing else to make variations and overrides more sensible to manage.

What about third-party design systems delivering what they deliver as… nothing but a big ol’ set of Custom Properties to use at your leisure?


Third-party deliverables don’t even have to be the entire kitchen sink like this. For example, Adam Argyle’s provides a “Hackpack” that is nothing but Custom Properties of transition animation helpers.

Understandabilty cost

One pushback I’ve heard against this more all-in approach on Custom Properties is newcomer understandability. If you wrote the system, it probably makes perfect sense to you. But it’s an additional abstraction on top of CSS. CSS knowledge is shared by all, bespoke systems knowledge is only shared by the people actively working on it.

Rolling in fresh to a system heavily using Custom Properties is going to have a heck of a learning curve.


The post Different Degrees of Custom Property Usage appeared first on CSS-Tricks. You can support CSS-Tricks by being an MVP Supporter.

Categories: Designing, Others Tags:

Open Source Development: Is it the right choice in 2021?

October 14th, 2021 No comments

A big yes! Open source development is no longer an underdog. Its popularity has exploded like a volcano. 

There’s no reason to say NO to it in 2021; in fact, it is to be analyzed that it is here to stay for many years to come. The reason for its remarkable supremacy isn’t just because it’s “free,” but also because it comes with a slew of benefits that make it easier for developers to use its beautiful features.

It helps developers develop specific approaches for creating computer programs and add tremendous value to their development skills. The beauty of open-source development has spread out its charm so much that now most of the software systems in the world are running through open-source development. 

Have many doubts popped out in your mind? 

Let’s dive deeper into open source development to know why it continues to shine like an evening star. 

Open Source Development: The origin

It was the era of 1991, when Linus Torvalds, a 21-year-old computer science student, announced that he would use a free operating system just as a hobby. He also said that it wouldn’t be as big and professional as GNU. He didn’t know that his hobby turned out to be the origin of the world’s first free operating system, the Linux kernel. The whole process then kickstarted the open-source software movement. 

After three decades later, a great thing happened. The open-source development sparked as one of the essential assets for businesses. From small companies to large firms, open-source development took a special place among the community of developers by expanding its omnipresence. Now, its awesomeness is greatly recreating the business models. In short, open-source development and deployment are epic in the business world. 

Open Source Development: Market Status 

When proprietary software providers and leading web development agencies dominated the market, open-source development was in the race but has picked up momentum lately, mainly in the outbreak of the COVID-19 pandemic. The global markets and economy have had a great hit in the pandemic, but open source development bonfires the remote organizations’ needs and offers them robust solutions. 

An excellent example of this is Microsoft. Earlier, Microsoft was not open source, and they are limited to specific fixed space. But with the growing popularity of open-source space, they realized this and came up with the .Net Core framework, which is open source and accepted globally. 

Just to spin the wheel, according to Github, open-source project production per active user between late April 2019 and late April 2020 observed over 40% YOY growth. An excellent win for open source development. It’s not all done. 

The significant usage of open source development amidst pandemic spiked the demand for the faster development for software programs and continued to step up its popularity ladder. 

Source: Octo Verse

According to the Red Hat® Report on the state of enterprise open source, 90% of IT leaders use open-source software. Moreover, 87% believe that open source software is more secure than proprietary software. The primary reason open-source development is in great demand by enterprises is improved security, higher quality, more access to innovation, etc. 

If we dive deeper, it’s worth knowing that open-source software has also become integral to cloud operating systems and edge computing architectures as well. Linux has rolled out as the best cloud operating system due to its superior flexibility and economical cost. According to Fortune Business Insights, the Global Linux Operating System Market Size is expected to hit USD 15.64 billion by 2027, exhibiting a CAGR of 19.2% during the forecast period. 

If the first open-source operating system is gaining so much recognition in the market, you can imagine the results of coming enterprise software designed with open source development.  Here’s the percentage of active repositories that rely on open source. 

Source: Octo Verse

Let’s keep rolling the dice!

Many of you may also have heard of TensorFlow. It is an open-source intelligence software released by Google. The great thing to know is it is now considered as the cherry-picked framework to design machine learning models.

NASA open source projects such as SpaceX API, Fprime, Webworldwind, Pulse, Pnasa, and many others are clearly evident how open source development is expanding its reach. 

The wide adoption of technology has influenced open-source development greatly. The rise and the rise of open source development are never-ending. 

Why Are Open-source Software Different From Other Software?

Open-source software is different from other software in multiple ways. Let’s understand the difference by shedding some light on important factors. 


Businesses pay for proprietary software. However, open-source Software isn’t owned by anybody. Anyone can use it free of cost if the company licenses its use from a commercial vendor. But just as with proprietary software licensing, open-source software is subject to numerous legal terms and restrictions, depending on the license type. Thus, it is essential to remain compliant with the open-source software licenses terms.  

Here is a list of popular open sources licenses that you must understand. 

Fully accessed and customized

The development of open Software is public; there is nothing confidential in the process. However, proprietary software and other Software development, such as closed source development, keep vendor information confidential. But in the open-source, code can be easily modified, tested, and freely distributed. 

Highly stable

Open-source software is understood as highly stable. Many leading businesses, while considering long-term projects, prefer open-source software as their first choice. The reason is pretty simple. Open-source software operates as per the open standards. 

Large community 

Open-source software has a massive community, is technically diverse, and is committed to unlocking digital technologies’ enigmas. Its vibrancy provides an edge, with the community assuring that software is developed quickly. In the words of Phillippe Kahn – 

“The power of open-source is the power of people – the people rule”

A problem has many solutions but it’s the right and feasible solution which needs to be considered and for that, we need more participation. With the involvement of many developers, a problem can be solved with the most viable solution.


Developers individually or as a team can find the optimum solutions to technical issues during open-source development to make Software much more reliable and secure. However, in other software development, such as closed software development, many limitations halt the smoothness of the development and deployment process. 


Developers find themselves more liable to improve an already existing software program to view or change the source code. However, in closed source software development or proprietary software development, more restrictions lie in the path of adding or removing code to a specific program. 


Open-source software development is one of the best ways to surge sales and earn better revenue. When you’ve complete control over your website or software, you can customize it according to your user’s growing needs. When your customers find your services delivered on time, the business will grow more quickly than ever. You can enjoy trust with your customers, which will ultimately help expand your business and services. 

The proprietary software development or closed source development, on the other hand, is also easier to set up and work with but doesn’t result in enormous benefits as open-source software. 

Is it going to be the next big thing in 2021?

Undoubtedly. Open source development is going to be the next big thing. The rising demand for cloud software is increasing, and thus, open-source software has secured a strong position in the digitally inspired economy.  By bringing impactful features into the digital-era world, where managing multiple operations for business becomes daunting, open-source development is emerging with limitless possibilities. 

A big thanks to its security features that make it possible to protect data from getting hacked by hackers. What do you think open source development is a new & small concept? Not anymore! It is now expanding its umbrella in artificial intelligence and machine learning. 

Source: Red Hat

Let’s dig deeper!

Open source development is a bundle of opportunities

If you use open source development in your enterprise, you can welcome dozens of opportunities to take your business to the next level. Especially if you’re planning to migrate your current enterprise software to the cloud, you can see enormous opportunities by using open source development. It will bring your software developers and analytics professionals closer to solving your enterprise problems and help them think differently to expand the business without worrying about infrastructure management. 

When developers work with collaboration, you can get a quick overview of their analytics for your business growth and thus analyze the success rate. The results? You can make adjustments and improvements in your business model and ensure consistency in everything. After all, “the key to success is consistency – Zak Frazer”. 

Open source development remodel on-going business practices

If you implement the best procedures and approaches in your business operations, nothing can stop it from flourishing its reach. Do you agree? You might be! 

Open source development gets a  big credit here too. You might have heard that analytics have evolved as top-notch business-critical practice. The new process CM (Continuous modeling) and CT (Continuous training ) are emerging as a beautiful way of analyzing and acting on insights faster. Both practices are fabulous in taking analytics out of the traditional lab-based to make business practices more agile, automated, and of course, reliable. 

Think of that moment when there was no way of analyzing data and insights. Now, with the rise of open-source software like Tensor Flow, it has become easier to reap the beautiful benefits of analytics and real-time insights. 

Multicloud and hybrid support

As we have already discussed, open-source development has massive community support; let’s shed some light on this statement. Community support (more likely to say freedom of open source) and power born from hybrid and multi-cloud strategy boost your data drawn-on capabilities. It means you can say goodbye to those powerful ways that are spoiling your data. As open source workloads are multi-cloud and aren’t dependent on multiple layered infrastructures, you can have more power and access to your choice. 

Google Cloud has always been a frontrunner of the multi-cloud and hybrid movements with the formulation of Anthos. It allows open space to work with where different services can be integrated. It is very simple, flexible, and secure as Open source projects fix vulnerabilities and release patches and new versions a lot faster. 

Open source brings Disintermediation

If you use open-source software, you can crack the gateways to decouple the abundance of things that may be the hurdle or roadblock for your work. For example: using Kubernetes, one of the best software for automating management, operations, and scaling of containerized applications, you can head on the new platform, where you can achieve more efficiency and productivity with proper management. 

With 79k stars and 102, 407 commits on Github, the Kubernetes has been widely used by leading players in the industry, such as Google Cloud, Amazon Web Services, and Microsoft Azure. 

Final Thoughts

If you have been thinking open source development is still in the progress stage, it’s one of the biggest misconceptions. Open source development has been appropriately established. Open source is now everywhere. The leading industry giants like Walmart are making the most from open source development. Its cloud management tool, OneOps is the perfect example to go through the high-end capabilities of open source development. 

Apart from that, Microsoft’s former CEO, who once declared Linux a cancer-like disease, relying on open source development. The list of giants using open software development is endless. 

Hopefully, this article has provided you with better insights about open source development, and you’d like to explore more about it.

Categories: Others Tags: