Ahmad Shadeed documents a bonafide CSS trick from the Facebook CSS codebase. The idea is that when an element is the full width of the viewport, it doesn’t have any border-radius. But otherwise, it has 8px of border-radius. Here’s the code:

.card {
  border-radius: max(0px, min(8px, calc((100vw - 4px - 100%) * 9999)));
}

One line! Super neat. The guts of it is the comparison between 100vw and 100%. Essentially, the border-radius comes out to 8px most of the time. But if the component becomes the same width as the viewport (within 4px, but I’d say that part is optional), then the value of the border-radius becomes 0px, because the equation yields a negative (invalid) number.

The 9999 multiplication means that you’ll never get low-positive numbers. It’s a toggle. You’ll either get 8px or 0px and nothing in between. Try removing that part, resizing the screen, and seeing it sorta morph as the viewport becomes close to the component size:

Why do it like this rather than at a @media query? Frank, the developer behind the Facebook choice, says:

It’s not a media query, which compares the viewport to a fixed width. It’s effectively a kind of container query that compares the viewport to its own variable width.

Frank Yan

And:

This is a more general purpose solution as it doesn’t need to know the size of the card. A media query would be dependent on the width of the card.

Naman Goel

The technique is apparently called the “Fab Four” Technique which is useful in emails.

Direct Link to Article — Permalink

The post Conditional Border Radius In CSS appeared first on CSS-Tricks. You can support CSS-Tricks by being an MVP Supporter.

PageSpeed Insights is a free performance measurement tool provided by Google. It analyzes the contents of a web page for desktop and mobile devices. It provides a single number score (from 1 to 100) that summarizes several underlying metrics that measure performance. If you have not run PageSpeed Insights on your website, then you should stop and do it now. It’s an important indicator of how Google scores and ranks your site.

If your PageSpeed Insights score is below 80, don’t panic. You are not alone. Many websites are not optimized for performance. The good news is that you can take steps that should immediately improve your score.

You will notice that PageSpeed Insights highlights issues that cause slow page loading. However, you might need more guidance to resolve these issues. Below, we walk you through how to resolve four common issues related to images. We also show you how ImageEngine, an image CDN, can simplify, automate, and deliver the best image optimization solution possible.

Performance Drives Google SEO Rankings

Why does the PageSpeed Insights score and performance matter? Isn’t SEO ranking all about content relevance, backlinks, and domain authority? Yes, but now performance matters more than it did a year ago. Starting in 2021, Google added performance metrics to the factors that impact search engine rankings. In a market where websites are constantly jockeying to match their competition’s pages (for content relevance, keywords, and other SEO issues), performance is making a difference in keyword search engine rankings.

What Are Core Web Vitals Metrics?

PageSpeed Insights relies on a set of performance metrics called Core Web Vitals. These metrics are:

Largest Contentful Paint (LCP): Measures the render time (in seconds) of the largest image or text block visible within the viewport, relative to when the page first started loading. Typically, the largest image is the hero image at the top of pages.

First Input Delay (FID): Measures the time from when a user first interacts with a page (i.e. when they click a link, tap on a button, or use a custom JavaScript-powered control) to the time when the browser is actually able to begin processing event handlers in response to that interaction.

Cumulative Layout Shift (CLS): Measures the layout shift that occurs any time a visible element changes its position from one rendered frame to the next.

Images and JavaScript are the Main Culprits

PageSpeed Insights breaks down problems into categories based upon how they impact these Core Web Vitals metrics. The top two reasons why you might have a low score are driven by JavaScript and images.

JavaScript issues are usually related to code that either blocks or delays page loading. For example, lazy-loading images might involve JavaScript that blocks loading. As a rule of thumb, do not use a third-party JavaScript library to manage image loading. These libraries frequently break the browser’s built-in image loading features. Lazy-loading may make above-the-fold images load slower (longer LCP) because the browser starts the download later and because the browser first has to execute the JavaScript.

Another JavaScript issue involves code that is large or unnecessary for the page. In other words, code bloat. There are good resources for resolving these issues on the web. However, in this blog, we will focus on image problems.

Images are a major contributor to poor performance. The average website payload is 2MB in 2021, and 50% of that is images. Frequently, images are larger than they need to be and can be optimized for size with no impact on quality…if you do it right.

Four Image Issues Highlighted by PageSpeed Insights

Largest Contentful Paint is the primary metric impacted by images. PageSpeed Insights frequently recommends the following four pieces of advice:

1. Serve images in next-gen formats.
2. Efficiently encode images.
3. Properly size images.
4. Avoid enormous network payloads.

That advice seems straightforward. Google provides some great advice on how to deal with images in its dev community. It can be summarized in the following steps:

• Select the appropriate file format.
• Apply the appropriate image compression.
• Apply the right display size.
• Render the image.
• Write responsive image code to select the right variant of the image.

We call Google’s process the “Build-Time Responsive Syntax” approach. If you have a relatively static website where you don’t generate new pages or switch out images frequently, then you can probably live with this approach. However, if you have a large and dynamic site with many images, then you will quickly feel the pain of this approach. Google itself stresses that developers should seek to automate this image process. Why? Because the process has some serious workflow drawbacks:

• Adds storage requirements due to a large increase in image variants.
• Increases code bloat and introduces more code complexity.
• Requires developers’ time and effort to create variants and implement responsiveness.
• Requires logic to account for different browser’s support for next-gen image formats.
• Doesn’t adapt to different contexts. It relies on best-guess (breakpoints) of what device visits the web page.
• Needs a separate CDN to further increase delivery speeds.
• Requires ongoing maintenance to adapt to new devices, breakpoints, image formats, markets, and practices.

Key Steps to Achieving High-Performance Images

Instead of using the Build-Time Responsive Syntax approach, an automated image CDN solution can address all of the image issues raised by PageSpeed Insights. The key steps of an image CDN that you should look for are:

1. Detect Mobile Devices: Detection of a website visitor’s device model and its technical capabilities. These include: OS version, browser version, screen pixel density, screen resolution width and height, support for next-gen image and video formats. This is where ImageEngine is unique in the market. ImageEngine uses true mobile device detection to further improve image optimization. It has a huge impact on the effectiveness of the image optimization process.
2. Optimize Images: An image CDN will leverage the device’s parameters to automatically resize, compress and convert large original images into optimized images with next-generation file formats, like WebP and AVIF. Frequently, an image CDN like ImageEngine will reduce the image payload by up to 80%.
3. Deliver by CDN: Image CDNs like ImageEngine have edge servers strategically positioned around the globe. By pushing optimized images closer to requesting customers and delivering them immediately from the cache, it often provides a 50% faster web page download time than traditional CDNs.

Easy Integration Process for Image CDN

After signing up for an ImageEngine account and free trial, you will receive a Delivery Address. After adjusting your elements to include the Delivery Address, ImageEngine will start to pull the original images from your website (no need to move or upload them), automatically optimize them, and deliver them.

You can automate the addition of the Delivery Address to the img src tag by using plug-ins for WordPress and Magento. Developers can also use ImageEngine’s React, Vue, or Angular JavaScript frameworks to simplify the process.

Additionally, there are many ways to simplify implementation via adjustments to templates for many CMS and eCommerce platforms.

Results: Improved Performance, Better SEO

Most ImageEngine users see a huge improvement in LCP metrics, and consequently, a big improvement in the overall PageSpeed Insights score. ImageEngine provides a free demo analysis of your images before and after image optimization. In many cases, developers see improvements of many seconds on their LCP and Speed Index.

In summary, performance drives higher search rankings, and better UX, and increases website conversions for eCommerce. The steps you take to improve your image performance will pay for themselves in more sales and conversions, streamlined workflow, and lower CDN delivery costs.

Source

The post 4 Steps to Improve PageSpeed Insights Score and SEO first appeared on Webdesigner Depot.

Remember that we’re simplifying for this example. I doubt that any team in the real world works with such a simple branching structure. However, it does help to understand the advantages and disadvantages of this model.

Firstly, you only have one branch which makes it easy to keep track of the changes in your project. Secondly, commits must be relatively small: you can’t risk big, bloated commits in an environment where things are constantly integrated into production code. As a result, your team’s testing and QA standards must be top notch! If you don’t have a high-quality testing environment, the mainline development approach won’t work for you. 

State, Release and Feature branches

Let’s look at the opposite now and how to work with multiple different types of branches. They all have a different job: new features and experimental code are kept in their own branches, releases can be planned and managed in their own branches, and even various states in your development flow can be represented by branches:

Remember that this all depends on your team’s needs and your project’s requirements. While this approach may look complicated at first, it’s all a matter of practise and getting used to it.

Now, let’s explore two main types of branches in more detail: long-running branches and short-lived branches.

Long-running branches

Every Git repository contains at least one long-running branch which is typically called master or main. Of course, your team may have decided to have other long-running branches in a project, for example something like develop, production or staging. All of those branches have one thing in common: they exist during the entire lifetime of a project. 

A mainline branch like master or main is one example for a long-running branch. Additionally, there are so-called integration branches, like develop or staging. These branches usually represent states in a project’s release or deployment process. If your code moves through different states in its development life cycle — e.g. from developing to staging to production — it makes sense to mirror this structure in your branches, too.

One last thing about long-running branches: most teams have a rule like “don’t commit directly to a long-running branch.” Instead, commits are usually integrated through a merge or rebase. There are two main reasons for such a convention:

• Quality: No untested or unreviewed code should be added to a production environment.
• Release bundling and scheduling: You might want to release new code in batches and even schedule the releases in advance.

Next up: short-lived branches, which are usually created for certain purposes and then deleted after the code has been integrated.

Short-lived branches

In contrast to long-running branches, short-lived branches are created for temporary purposes. Once they’ve fulfilled their duty and the code has been integrated into the mainline (or another long-lived branch), they are deleted. There are many different reasons for creating a short-lived branch, e.g. starting to work on a new and experimental feature, fixing a bug, refactoring your code, etc.

Typically, a short-lived branch is based on a long-running branch. Let’s say you start working on a new feature of your software. You might base the new feature on your long-running main branch. After several commits and some tests you decide the work is finished. The new feature can be integrated into the main branch, and after it has been merged or rebased, the feature branch can be deleted. 

Two popular branching strategies

In the last section of this article, let’s look at two popular branching strategies: Git Flow and GitHub Flow. While you and your team may decide on something completely different, you can take them as inspiration for your own branching strategy.

Git Flow

One well-known branching strategy is called

This article is part of our “Advanced Git” series. Be sure to follow us on Twitter or sign up for our newsletter to hear about the next articles!

Almost all version control systems (VCS) have some kind of support for branching. In a nutshell, branching means that you leave the main development line by creating a new, separate container for your work and continue to work there. This way you can experiment and try out new things without messing up the production code base. Git users know that Git’s branching model is special and incredibly powerful; it’s one of the coolest features of this VCS. It’s fast and lightweight, and switching back and forth between the branches is just as fast as creating or deleting them. You could say that Git encourages workflows that use a lot of branching and merging.

Git totally leaves it up to you how many branches you create and how often you merge them. Now, if you’re coding on your own, you can choose when to create a new branch and how many branches you want to keep. This changes when you’re working in a team, though. Git provides the tool, but you and your team are responsible for using it in the optimal way!

In this article, I’m going to talk about branching strategies and different types of Git branches. I’m also going to introduce you to two common branching workflows: Git Flow and GitHub Flow.

Teamwork: Write down a convention

Before we explore different ways of structuring releases and integrating changes, let’s talk about conventions. If you work in a team, you need to agree on a common workflow and a branching strategy for your projects. It’s a good idea to put this down in writing to make it accessible to all team members.

Admittedly, not everyone likes writing documentation or guidelines, but putting best practise on record not only avoids mistakes and collisions, it also helps when onboarding new team members. A document explaining your branching strategies will help them to understand how you work and how your team handles software releases.

Here are a couple of examples from our own documentation:

• master represents the current public release branch
• next represents the next public release branch (this way we can commit hotfixes on master without pulling in unwanted changes)
• feature branches are grouped under feature/
• WIP branches are grouped under wip/ (these can be used to create “backups” of your personal WIP)

A different team might have a different opinion on these things (for example on “wip” or “feature” groups), which will certainly be reflected in their own documentation.

Integrating changes and structuring releases

When you think about how to work with branches in your Git repositories, you should probably start with thinking about how to integrate changes and how to structure releases. All those topics are tightly connected. To help you better understand your options, let’s look at two different strategies. The examples are meant to illustrate the extreme ends of the spectrum, which is why they should give you some ideas of how you can design your own branching workflow:

• Mainline Development
• State, Release, and Feature Branches

The first option could be described as “always be integrating” which basically comes down to: always integrate your own work with the work of the team. In the second strategy you gather your work and release a collection of it, i.e. multiple different types of branches enter the stage. Both approaches have their pros and cons, and both strategies can work for some teams, but not for others. Most development teams work somewhere in between those extremes.

Let’s start with the mainline development and explain how this strategy works.

Mainline Development

I said it earlier, but the motto of this approach is “always be integrating.” You have one single branch, and everyone contributes by committing to the mainline:

Remember that we’re simplifying for this example. I doubt that any team in the real world works with such a simple branching structure. However, it does help to understand the advantages and disadvantages of this model.

Firstly, you only have one branch which makes it easy to keep track of the changes in your project. Secondly, commits must be relatively small: you can’t risk big, bloated commits in an environment where things are constantly integrated into production code. As a result, your team’s testing and QA standards must be top notch! If you don’t have a high-quality testing environment, the mainline development approach won’t work for you. 

State, Release and Feature branches

Let’s look at the opposite now and how to work with multiple different types of branches. They all have a different job: new features and experimental code are kept in their own branches, releases can be planned and managed in their own branches, and even various states in your development flow can be represented by branches:

Remember that this all depends on your team’s needs and your project’s requirements. While this approach may look complicated at first, it’s all a matter of practise and getting used to it.

Now, let’s explore two main types of branches in more detail: long-running branches and short-lived branches.

Long-running branches

Every Git repository contains at least one long-running branch which is typically called master or main. Of course, your team may have decided to have other long-running branches in a project, for example something like develop, production or staging. All of those branches have one thing in common: they exist during the entire lifetime of a project. 

A mainline branch like master or main is one example for a long-running branch. Additionally, there are so-called integration branches, like develop or staging. These branches usually represent states in a project’s release or deployment process. If your code moves through different states in its development life cycle — e.g. from developing to staging to production — it makes sense to mirror this structure in your branches, too.

One last thing about long-running branches: most teams have a rule like “don’t commit directly to a long-running branch.” Instead, commits are usually integrated through a merge or rebase. There are two main reasons for such a convention:

• Quality: No untested or unreviewed code should be added to a production environment.
• Release bundling and scheduling: You might want to release new code in batches and even schedule the releases in advance.

Next up: short-lived branches, which are usually created for certain purposes and then deleted after the code has been integrated.

Short-lived branches

In contrast to long-running branches, short-lived branches are created for temporary purposes. Once they’ve fulfilled their duty and the code has been integrated into the mainline (or another long-lived branch), they are deleted. There are many different reasons for creating a short-lived branch, e.g. starting to work on a new and experimental feature, fixing a bug, refactoring your code, etc.

Typically, a short-lived branch is based on a long-running branch. Let’s say you start working on a new feature of your software. You might base the new feature on your long-running main branch. After several commits and some tests you decide the work is finished. The new feature can be integrated into the main branch, and after it has been merged or rebased, the feature branch can be deleted. 

Two popular branching strategies

In the last section of this article, let’s look at two popular branching strategies: Git Flow and GitHub Flow. While you and your team may decide on something completely different, you can take them as inspiration for your own branching strategy.

Git Flow

One well-known branching strategy is called Git Flow. The main branch always reflects the current production state. There is a second long-running branch, typically called develop. All feature branches start from here and will be merged into develop. Also, it’s the starting point for new releases: developers open a new release branch, work on that, test it, and commit their bug fixes on such a release branch. Once everything works and you’re confident that it’s ready for production, you merge it back into main. As the last step, you add a tag for the release commit on main and delete the release branch.

Git Flow works pretty well for packaged software like (desktop) applications or libraries, but it seems like a bit of an overkill for website projects. Here, the difference between the main branch and the release branch is often not big enough to benefit from the distinction. 

If you’re using a Git desktop GUI like Tower, you’ll find the possible actions in the interface and won’t have to memorize any new commands:

GitHub Flow

If you and your team follow the continuous delivery approach with short production cycles and frequent releases, I would suggest looking at GitHub Flow. 

It’s extremely lean and simple: there is one long-running branch, the default main branch. Anything you’re actively working on has its own separate branch. It doesn’t matter if that’s a feature, a bug fix, or a refactoring.

What’s the “best” Git branching strategy?

If you ask 10 different teams how they’re using Git branches, you’ll probably get 10 different answers. There is no such thing as the “best” branching strategy and no perfect workflow that everyone should adopt. In order to find the best model for you and your team, you should sit down together, analyze your project, talk about your release strategy, and then decide on a branching workflow that supports you in the best possible way.

If you want to dive deeper into advanced Git tools, feel free to check out my (free!) “Advanced Git Kit”: it’s a collection of short videos about topics like branching strategies, Interactive Rebase, Reflog, Submodules and much more.

The post Branching Strategies in Git appeared first on CSS-Tricks. You can support CSS-Tricks by being an MVP Supporter.

This is some bonafide CSS trickery from Harry that gives you some generic performance advice based on what it sees in your element.

First, it’s possible to make a block visible like any other element by changing the display away from the default of none. It’s a nice little trick. You can even do that for things in the , for example…

head,
head style,
head script {
  display: block;
}

From there, Harry gets very clever with selectors, determining problematic situations from the usage and placement of certain tags. For example, say there is a that comes after some styles…

<head>
  <link rel="stylesheet" href="...">
  <script src="..."></script>
  <title>Page Title</title>
  <!-- ...  -->

Well, that’s bad, because the script is blocked by CSS likely unnecessarily. Perhaps some sophisticated performance tooling software could tell you that. But you know what else can? A CSS selector!

head [rel="stylesheet"]:not([media="print"]):not(.ct) ~ script,
head style:not(:empty) ~ script {

}

That’s kinda like saying head link ~ script, but a little fancier in that it only selects actual stylesheets or style blocks that are truly blocking (and not itself). Harry then applies styling and pseudo-content to the blocks so you can use the stylesheet as a visual performance debugging tool.

That’s just darn clever, that. The stylesheet has loads of little things you can test for, like attributes you don’t need, blocking resources, and elements that are out of order.

Direct Link to Article — Permalink

The post ct.css — Performance Hints via Injected Stylesheet Alone appeared first on CSS-Tricks. You can support CSS-Tricks by being an MVP Supporter.

Let’s assume that you are running a national food chain business. You just launched a new line of organic foods and you want to update your eCommerce marketing strategy accordingly.

When you think of “Organic food” you must have a specific audience in your mind. You must have made assumptions about their age, ethnicity, and location. For the most part, these assumptions might be true.

But, truth be told, if you are looking forward to strategizing for a better eCommerce solution, decisions should not be made based on assumptions.

With such fierce competition, extensive market research is not dispensable. For businesses of all sizes, market analysis, and research is the key to success. Unfortunately, most of the tools available for that purpose are quite expensive, complicated, and time-consuming. To figure out who is looking for your product and what regions to tackle, the best tool available is Google Trends.

What is Google Trends Anyway? 

Google Trends is a powerful tool developed by Google. It provides complete insight into how different search queries are entered in search engines and how people are using the search engines around the world. When you know what people are searching for, you can understand how and what are they thinking. 

Google Trends allows users to track the popularity of search terms over time, look for related phrases, and compare how popular a search term is in different parts of the world. Google Trends can also be used to spot spikes in search volumes of certain keywords, which are often caused by real-world events.

In this article, we will discuss in detail how Google Trends can help you improve your eCommerce marketing. So let’s deep dive into the details of the topic.

1. Utilizing Google Trends to find Hot Topics in your Industry

The world is now moving at a pace that each day there is something new to talk about. Trends change within a matter of seconds let alone days or months. Therefore, it is important that you are well aware of every ongoing trend in your industry. This is where Google Trends play the part. You can easily find the popular topics through Google Trends. Here is how:

Go to Google Trends

Step 1: Click on Explore from the Menu

Step 2: Select the Location you want to analyze. You can search for a whole country, state, or city.

Step 3: Choose the time interval you want. Depending on your requirements you can analyze topics that are currently trending or complete data of previous months or even a year.

Step 4: Select your category or Industry. For example, if you work in marketing then select marketing or food or so on.

Step 5: Explore and Analyze different search topics and queries related to your niche. You will find all sorts of data. You will have to do some work to filter out the data that is useful for your eCommerce business.

2. Set Realistic Traffic and Revenue Goals

Many organizations set their quarterly sales goals for the coming year during annual planning. Time after time, different companies deplorably miss their targets during one quarter, before knocking the ball out of the park for the next one. This arises when goals are either perfectly averaged over four quarters or set before you have a good understanding of seasonal spending patterns.

The key is to set realistic targets that are achievable rather than aiming for something that is not feasible. Prior to setting targets, use Google Trends to tabulate seasonal data of your top-selling products. This method is better suited to eCommerce businesses that are more focused on bootstrapping their top revenue-generating product without having to include a large number of search phrases. (However, the more search phrases you include, the better you’ll be able to confirm what the data is telling you.)

For stores that sell a large variety of products throughout the year, it will be hard to use Google Trends to get a clear picture of seasonal trends at a higher level. The hack here is to use keywords that only an active shopper at your store would use. This way you can get enough data to analyze the seasonal performance.

3. Sync your Calendar with Google Trends

An editorial calendar is as important as any other aspect of eCommerce strategy if not less. An editorial calendar lets you constructively manage your content by managing the timeline.

The seasonality of product searches emphasizes something that should be obvious: people have varied demands at different times of the year. They must investigate various pain areas, investigate various solutions, test various how-tos, and organize their approach to various occasions and holidays. They also have diverse emotions and motivations.

Search Google Trends for the themes you frequently cover to see when you should focus your content on them for the best SEO results. One technique you might do is to create evergreen pages but refresh the material prior to each new seasonal spike — this ensures that your page maintains its SEO equity while also providing up-to-date, pertinent content to site visitors. You can also look for patterns relating to upcoming events and holidays to get ideas for new material. To come up with topic ideas, try different inquiries and keywords in connection with the holiday.

4. Understanding Your Audience

Google has evolved into more of an institution than a search engine as the most popular search engine. As a result, their search data is extremely reflective of public sentiment and interests. You may take advantage of this by learning about public opinion in your sector.

Use Google Trends to see how our industry’s perception has changed over time and where it stands currently.

Get started with Google Trends by learning the basics. In the search box above, type some key phrases that you believe indicate a difference in opinion and understanding of your sector. As shown in the graph below.

This graph will show you the search trends over a certain time interval for specific phrases compared to each other for a particular industry.

5. Using Google Trends to find Paying Niches

Google Trends is an excellent resource for locating a rapidly growing market. You should modify your range from “past 12 months” to “2021-present” whenever you’re looking for a new niche. This allows you to monitor whether the volume of searches is increasing or decreasing. However, it also allows you to see seasonal trends in a single, clear image. 

Consider the example of a skyrocketing product discussed below: Posture Corrector

You can easily observe clear growth during the last several months. We noticed a sharp increase in January, followed by a minor decrease in February. However, this does not rule out the possibility of profiting from sales. As a result, this popular product will need to be watched for a little longer.

On the other, if you analyze a more stable niche such as men’s fashion, you will observe that:

There are tiny dips in the graph, which can be seen clearly. The search traffic for this specialty, on the other hand, is quite consistent. It’s typical to witness some little dips or increases over the course of several years. However, Google Trends indicates that men’s fashion is a somewhat steady niche. You might be wondering what the peaks and valleys on the graph mean. These demonstrate the seasonal trends in search volume. There is an increase in searches from October through December, with a fall beginning in January. That isn’t to say you shouldn’t open a men’s fashion store in January; it just means you’ll get less website traffic at that time of year.

Now let’s consider a third example. How does a fading trend look like on Google Trends? Let’s consider the graph below for the keyphrase fidget spinner.

Until February 2017, there were almost no searches for “fidget spinners.” The product peaked three months later, in May. It’s apparent that in the first few months, there was a significant surge in attention. However, the steep drop since the top indicates that this is no longer a viable commercial venture to pursue.

6. Thorough keyword research with Google Trends

Assume you run a business that sells women’s blouses. According to Google Trends, searches for this are increasing, which is a good sign. However, you must now determine which keywords to target, how to name your product categories, and how to optimize a blog article about women’s blouses. Take a brief glance at “Related questions,” which is located on the right side of the “Related Topics” section we just discussed.

There is a constant callout to color across all the queries. There are two listings for the color black in the chart above. White, blue, pink, and green can be found on different sites. For these cases, you would want to construct a color-based product category, such as “black blouses.” However, you may also use such keywords in the title of your product and on the product page. “Women’s shirts” or “women’s blouses” might potentially be added as a product category because they have a lot of searches and make sense for this type of clothing.

7. Google Trends and YouTube Trends

While Google Trends is most commonly used to improve the online standing of your eCommerce store, you can also utilize it to expand your social media reach, particularly on YouTube. After searching YouTube for “fashion” videos, we discovered that the most popular ones used the phrase “fashion trends 2019.” So, let’s see what we get if we plug that into Google Trends.

The popularity of this search keyword increased in January. Naturally, the addition of the year to the keyword will make it a hot search term at the start of the year. We observed something intriguing after returning to YouTube and searching for “fashion trends 2019” in the search bar. Take a look at the following:

Each of the top videos was released in the year 2019. What makes this intriguing? Because vloggers (and bloggers) frequently post content before the new year to gain a jump start on visitors. However, we see that when content is produced in 2019, it scores fairly well in the top results.

So, if you’re planning to make a film about fashion trends in 2019, your best bet is to release it in January to take advantage of the data from Google Trends.

Let’s take a step back for a moment. Because we won’t know what the data for the remainder of 2019 will be, let’s look at the data for “fashion trends 2018” to see what we may expect in the coming year.

As a result, we can see that at the end of 2017, Youtube users began searching for the term “fashion trends 2018.” Then there’s that January increase we noticed in our 2019 graph. However, there are higher rises in March and September – immediately before summer and right before winter, respectively.

How can you make the most of the traffic during those times? If you have an email list, you may send an email in March and September to re-invigorate your video’s popularity. When Google notices that you’re pushing older video content, it’ll likely reward you with a higher ranking for your video, allowing you to earn more views. This method can also be used if you see that views on popular evergreen videos are dwindling.

Final Thoughts on Using Google Trends

Experimenting with Google Trends is the greatest approach to fully utilize its capabilities. Experiment with various keywords, themes, and comparisons. Use a variety of timelines, categories, and locations. Keep an eye on the most popular searches. Become enthralled. The more you look, the more vital keyword information you’ll find. Make use of this knowledge to ensure that your website responds to whatever your audience is thinking about.