Bitly’s new preview page, which adds an extra click and includes ads, undermines the simplicity and efficiency that made the service popular. Users now face the choice of dealing with interruptions or paying for a premium plan, making Bitly less appealing as a URL shortening tool.
Google Maps in India is a great example of designing with real people in mind, tackling everything from landmark-based directions to language barriers and patchy internet. By listening to users and testing in the chaos of real-life streets, Google created a navigation tool that millions now rely on every day.
Social media has transformed B2B marketing by providing a strategic platform for businesses to connect with potential clients, build relationships, and enhance brand visibility. Unlike traditional marketing, social media allows for real-time interaction and engagement, offering insights into audience preferences and behaviors. This level of interaction is crucial for establishing trust and credibility in a crowded marketplace. This type of marketing can entail everything from influencer marketing to live streaming and must be approached strategically for optimal outcomes.
The sales funnel is the heart of effective B2B marketing. It illustrates the customer journey from initial awareness to final conversion. The funnel comprises several stages: awareness, interest, consideration, intent, evaluation, and purchase. Social media is a critical tool at every stage, helping brands capture prospects’ attention, nurture leads through informative content, and ultimately facilitate conversions.
By implementing targeted social media tactics tailored to each phase, B2B companies can enhance their marketing efforts, improve ROI, and drive sustainable growth.
To capture the attention of your target audience, start by producing high-quality, relevant content that addresses their pain points and interests. Utilize formats like infographics, videos, and case studies to convey information in an engaging manner. Additionally, including storytelling elements can make your messaging relatable and memorable.
Leverage social media advertising to enhance brand visibility by targeting specific demographics based on job role, industry, and interests. Platforms like LinkedIn and Facebook allow for tailored ads that can reach your ideal audience effectively. Don’t underestimate the power of influencer marketing, either. This new frontier in marketing allows you to give your brand a voice audiences trust. It’s also essential if you’re targeting young audiences.
Track KPIs such as impressions, engagement rates (likes, shares, comments), and click-through rates to measure the effectiveness of your brand awareness initiatives. Monitoring website traffic and conversion rates from social media can provide insights into how well your campaigns are fostering awareness and interest. Adjust your strategies based on these insights to optimize your efforts continually.
Nurturing leads involves building relationships with potential clients over time, guiding them through the purchasing journey with valuable information and personalized interactions. It looks like providing relevant resources, responding to inquiries promptly, and fostering trust to encourage prospects to move closer to a purchase decision. Captivating prospects through meaningful content and authentic engagement is essential for nurturing leads effectively. This can be achieved through:
Fostering a community on social media allows for deeper connections with prospects, turning them into loyal customers who feel invested in your brand’s journey.
The following are some practical strategies to effectively transform leads into customers:
Implementing these strategies creates a compelling narrative that resonates with leads and encourages them to make a purchasing decision influenced by social proof and personalized engagement.
By leveraging social media management tools, businesses can enhance their social media strategies and drive successful engagement with their audience. Using these tools can significantly enhance a business’s efficiency by streamlining content creation, scheduling, and analytics tracking. These tools can also enable companies to maintain a consistent online presence, ultimately leading to improved engagement rates and better overall business outcomes. Key social media management tools may include the following:
By leveraging a combination of these tools, businesses can enhance their social media strategies and drive successful engagement with their audience.
The journey from awareness to conversion in the B2B landscape is a deliberate process hinges on a cohesive social media strategy. Initially, businesses must capture the attention of potential leads through insightful content that speaks to their pain points and interests. As engagement grows, nurturing relationships becomes paramount; crafting personalized interactions can build trust and credibility.
Companies can streamline efforts and optimize their content by leveraging the right social media management tools — ranging from scheduling platforms to engagement analytics. This approach facilitates consistent communication and enhances the overall user experience with visually appealing and relevant messaging.
Featured image by Kerde Severin
The post From Awareness to Conversion: Social Media Tactics for B2B Success appeared first on noupe.
Adam’s such a mad scientist with CSS. He’s been putting together a series of “notebooks” that make it easy for him to demo code. He’s got one for gradient text, one for a comparison slider, another for accordions, and the list goes on.
One of his latest is a notebook of scroll-driven animations. They’re all impressive as heck, as you’d expect from Adam. But it’s the simplicity of the first few examples that I love most. Here I am recreating two of the effects in a CodePen, which you’ll want to view in the latest version of Chrome for support.
This is a perfect example of how a scroll-driven animation is simply a normal CSS animation, just tied to scrolling instead of the document’s default timeline, which starts on render. We’re talking about the same set of keyframes:
@keyframes slide-in-from-left {
from {
transform: translateX(-100%);
}
}All we have to do to trigger scrolling is call the animation and assign it to the timeline:
li {
animation: var(--animation) linear both;
animation-timeline: view();
}Notice how there’s no duration set on the animation. There’s no need to since we’re dealing with a scroll-based timeline instead of the document’s timeline. We’re using the view() function instead of the scroll() function, which acts sort of like JavsScript’s Intersection Observer where scrolling is based on where the element comes into view and intersects the scrollable area.
It’s easy to drop your jaw and ooo and ahh all over Adam’s demos, especially as they get more advanced. But just remember that we’re still working with plain ol’ CSS animations. The difference is the timeline they’re on.
Scroll Driven Animations Notebook originally published on CSS-Tricks, which is part of the DigitalOcean family. You should get the newsletter.
And so, this is how the chatbots revolutionized the beauty care industry…
This is the disruption that experts were talking about. Yet, many experts were skeptical of how an AI chatbot could add the human element to the beauty industry. Today chatbots have become a reality with leading beauty brands such as Sephora, L’oreal Paris, Covergirl, and Kiehl’s using it in their process, with other brands on their way of doing so. And if you’re planning to do the same, there are many chatbot providers in the market that you can look for.
But what exactly are chatbots? If you don’t have precise knowledge about it, read on for absolute information.
It is one of the latest technologies; the programs that facilitate communication with humans over the internet. There are chiefly two types of chatbots: rule-based chatbots and AI chatbots. The rule-based chatbots convey the repetitive answers to common queries, while AI chatbots can carry out human-like conversations. Therefore, these AI bots are popular in the customer service, marketing, and sales departments.
Now a crucial question- Have you contacted a customer representative by phone or asked queries in chat?
Many people have, at some point. For instance, we have inquired with agents about banking services, mobile services, and so on. But have you noticed the services aren’t as instant as those provided by bots?
And why is that? The agents are humans, and they take their time to execute the process. In this scenario, the chatbot’s role comes into play. These bots are really fast as they are intelligently designed. They are the AI employees on their toes, willing to go the extra mile to make the customer happy (without themselves knowing it) ?
A happy customer means you won the business game in the long run.
A quote by Tim Horst, an online marketing expert, perfectly fits the context:
“Chatbots are similar to WhatsApp. If you don’t use technology wisely, you won’t be successful. However, when chatbots are well made and help customers, they’re extremely well-received by customers.”
Tim Horst
So, how exactly would chatbots revolutionize the beauty care industry?
Every person is unique. We can’t use the same beauty products for all, as it could worsen the existing conditions.
AI chatbots in the customer service sector of beauty care companies are here to provide customized beauty solutions. It includes planning skin regimen, matching hair color, and many others. In the future, we could expect even more advanced solutions that might eliminate physical visits.
Below you can see the global growth of AI (AI chatbot) in the beauty and cosmetics market:
As you can see here, the global AI (which chatbots are part of) in the beauty and cosmetics market is expected to grow at a CAGR of 19.8%. The forecasted market size for 2033 is USD $16.4B. That’s an impressive rate; don’t you think so?
Now, we’d talk about how exactly it works and would change the entire work structure in the beauty care industry:
Chatbots could accurately predict future trends where even some human service agents fail. This happens because these intelligent chatbots can record past trends, interests, queries, and others.
In the below image, you can see how an AI chatbot works:
Here the user initiates a request, which is then analyzed using NLP (natural language processing). It further leads to a real-time response, further analyzed using machine learning and deep learning- components of artificial intelligence. This technology facilitates a better user experience and boosts revenue.
AI chatbots analyze the pulse of the customer and interact accordingly. The customer receives personalized information on the latest and upcoming trends. With accurate predictions and suggestions, it makes the customer satisfied.
Good customer experience often leads to better customer lifetime value.
The AI could anticipate required beauty solutions in a short time.
This is a breakthrough and useful for the customer service department in the beauty care industry. The entire process becomes fast and streamlined. In the below image, you can see how it analyzes the solutions for a customer:
Cetaphil is a well-known brand and is popular among users. The brand has a skin analysis tool. The process starts when the customer needs to upload her/his selfie, then the brand moves onto the next stage of providing the right solutions such as recommendations for sensitive skin, what skincare products not to use, how many times to use a product in a day, etc.
The brand celebrates individuality and meets the needs of customers.
Just imagine a scenario, where you provide training to human agents and they leave after a few months. Isn’t that a loss for the company?
In the case of chatbots, they aren’t going anywhere- you could say they are your loyal employees and need some updates at a specific time!!
Additionally, they reduce costs by working for various beauty services and different customers concurrently.
Find the below image to understand how a chatbot could handle multiple tasks in this industry:
In the above image, you can see chatbots interacting with customers for different services through questions and answers such as:
What’s your current top beauty concern? How much time daily do you need for your beauty routine? Specific beauty goals an individual is looking for? Favorite skincare products or must-have ingredients? Specific skin type or concern for personalized advice and so on.
The entire work structure shows how smart these chatbots are. Organizations now don’t need a high number of professionals to handle such queries. That doesn’t imply you could entirely eliminate the human role; you still need professionals for critical customer services.
Chatbots have already revolutionized the process in various departments of reputable organizations. With further advancement in technology, we’d see high performance of these bots.
Featured image by Camille Brodard on Unsplash
The post How Chatbots Could Revolutionize Beauty Care Industry? appeared first on noupe.
This article is a sponsored by DebugBear
Loading your website HTML quickly has a big impact on visitor experience. After all, no page content can be displayed until after the first chunk of the HTML has been loaded. That’s why the Time to First Byte (TTFB) metric is important: it measures how soon after navigation the browser starts receiving the HTML response.
Generating the HTML document quickly plays a big part in minimizing TTFB delays. But actually, there’s a lot more to optimizing this metric. In this article, we’ll take a look at what else can cause poor TTFB and what you can do to fix it.
What Components Make Up The Time To First Byte Metric?
TTFB stands for Time to First Byte. But where does it measure from?
Different tools handle this differently. Some only count the time spent sending the HTTP request and getting a response, ignoring everything else that needs to happen first before the resource can be loaded. However, when looking at Google’s Core Web Vitals, TTFB starts from the time when the users start navigating to a new page. That means TTFB includes:
We can see an example of this in this request waterfall visualization.
The server response time here is only 183 milliseconds, or about 12% of the overall TTFB metric. Half of the time is instead spent on a cross-origin redirect — a separate HTTP request that returns a redirect response before we can even make the request that returns the website’s HTML code. And when we make that request, most of the time is spent on establishing the server connection.
Connecting to a server on the web typically takes three round trips on the network:
What Network Latency Means For Time To First Byte
Let’s add up all the network round trips in the example above:
That means that before we even get the first response byte for our page we actually have to send data back and forth between the browser and a server eight times!
That’s where network latency comes in, or network round trip time (RTT) if we look at the time it takes to send data to a server and receive a response in the browser. On a high-latency connection with a 150 millisecond RTT, making those eight round trips will take 1.2 seconds. So, even if the server always responds instantly, we can’t get a TTFB lower than that number.
Network latency depends a lot on the geographic distances between the visitor’s device and the server the browser is connecting to. You can see the impact of that in practice by running a global TTFB test on a website. Here, I’ve tested a website that’s hosted in Brazil. We get good TTFB scores when testing from Brazil and the US East Coast. However, visitors from Europe, Asia, or Australia wait a while for the website to load.
What Content Delivery Networks Mean for Time to First Byte
One way to speed up your website is by using a Content Delivery Network (CDN). These services provide a network of globally distributed server locations. Instead of each round trip going all the way to where your web application is hosted, browsers instead connect to a nearby CDN server (called an edge node). That greatly reduces the time spent on establishing the server connection, improving your overall TTFB metric.
By default, the actual HTML request still has to be sent to your web app. However, if your content isn’t dynamic, you can also cache responses at the CDN edge node. That way, the request can be served entirely through the CDN instead of data traveling all across the world.
If we run a TTFB test on a website that uses a CDN, we can see that each server response comes from a regional data center close to where the request was made. In many cases, we get a TTFB of under 200 milliseconds, thanks to the response already being cached at the edge node.
How To Improve Time To First Byte
What you need to do to improve your website’s TTFB score depends on what its biggest contributing component is.
Keep in mind that TTFB depends on how visitors are accessing your website. For example, if they are logged into your application, the page content probably can’t be served from the cache. You may also see a spike in TTFB when running an ad campaign, as visitors are redirected through a click-tracking server.
Monitor Real User Time To First Byte
If you want to get a breakdown of what TTFB looks like for different visitors on your website, you need real user monitoring. That way, you can break down how visitor location, login status, or the referrer domain impact real user experience.
DebugBear can help you collect real user metrics for Time to First Byte, Google Core Web Vitals, and other page speed metrics. You can track individual TTFB components like TCP duration or redirect time and break down website performance by country, ad campaign, and more.
Conclusion
By looking at everything that’s involved in serving the first byte of a website to a visitor, we’ve seen that just reducing server response time isn’t enough and often won’t even be the most impactful change you can make on your website.
Just because your website is fast in one location doesn’t mean it’s fast for everyone, as website speed varies based on where the visitor is accessing your site from.
Content Delivery Networks are an incredibly powerful way to improve TTFB. Even if you don’t use any of their advanced features, just using their global server network saves a lot of time when establishing a server connection.
We’ve been able to get the length of the viewport in CSS since… checks notes… 2013! Surprisingly, that was more than a decade ago. Getting the viewport width is as easy these days as easy as writing 100vw, but what does that translate to, say, in pixels? What about the other properties, like those that take a percentage, an angle, or an integer?
Think about changing an element’s opacity, rotating it, or setting an animation progress based on the screen size. We would first need the viewport as an integer — which isn’t currently possible in CSS, right?
What I am about to say isn’t a groundbreaking discovery, it was first described amazingly by Jane Ori in 2023. In short, we can use a weird hack (or feature) involving the tan() and atan2() trigonometric functions to typecast a length (such as the viewport) to an integer. This opens many new layout possibilities, but my first experience was while writing an Almanac entry in which I just wanted to make an image’s opacity responsive.
Resize the CodePen and the image will get more transparent as the screen size gets smaller, of course with some boundaries, so it doesn’t become invisible:
This is the simplest we can do, but there is a lot more. Take, for example, this demo I did trying to combine many viewport-related effects. Resize the demo and the page feels alive: objects move, the background changes and the text smoothly wraps in place.
I think it’s really cool, but I am no designer, so that’s the best my brain could come up with. Still, it may be too much for an introduction to this typecasting hack, so as a middle-ground, I’ll focus only on the title transition to showcase how all of it works:
The idea behind this is to convert 100vw to radians (a way to write angles) using atan2(), and then back to its original value using tan(), with the perk of coming out as an integer. It should be achieved like this:
:root {
--int-width: tan(atan2(100vw, 1px));
}But! Browsers aren’t too keep on this method, so a lot more wrapping is needed to make it work across all browsers. The following may seem like magic (or nonsense), so I recommend reading Jane’s post to better understand it, but this way it will work in all browsers:
@property --100vw {
syntax: "<length>";
initial-value: 0px;
inherits: false;
}
:root {
--100vw: 100vw;
--int-width: calc(10000 * tan(atan2(var(--100vw), 10000px)));
}Don’t worry too much about it. What’s important is our precious --int-width variable, which holds the viewport size as an integer!
Right now we have the viewport as an integer, but that’s just the first step. That integer isn’t super useful by itself. We oughta convert it to something else next since:
Think about an image’s opacity going from 0 to 1, an object rotating from 0deg to 360deg, or an element’s offset-distance going from 0% to 100%. We want to interpolate between these values as --int-width gets bigger, but right now it’s just an integer that usually ranges between 0 to 1600, which is inflexible and can’t be easily converted to any of the end values.
The best solution is to turn --int-width into a number that goes from 0 to 1. So, as the screen gets bigger, we can multiply it by the desired end value. Lacking a better name, I call this “0-to-1” value --wideness. If we have --wideness, all the last examples become possible:
/* If `--wideness is 0.5 */
.element {
opacity: var(--wideness); /* is 0.5 */
translate: rotate(calc(wideness(400px, 1200px) * 360deg)); /* is 180deg */
offset-distance: calc(var(--wideness) * 100%); /* is 50% */
}So --wideness is a value between 0 to 1 that represents how wide the screen is: 0 represents when the screen is narrow, and 1 represents when it’s wide. But we still have to set what those values mean in the viewport. For example, we may want 0 to be 400px and 1 to be 1200px, our viewport transitions will run between these values. Anything below and above is clamped to 0 and 1, respectively.
In CSS, we can write that as follows:
:root {
/* Both bounds are unitless */
--lower-bound: 400;
--upper-bound: 1200;
--wideness: calc(
(clamp(var(--lower-bound), var(--int-width), var(--upper-bound)) - var(--lower-bound)) / (var(--upper-bound) - var(--lower-bound))
);
}Besides easy conversions, the --wideness variable lets us define the lower and upper limits in which the transition should run. And what’s even better, we can set the transition zone at a middle spot so that the user can see it in its full glory. Otherwise, the screen would need to be 0px so that --wideness reaches 0 and who knows how wide to reach 1.
--wideness. What’s next?For starters, the title’s markup is divided into spans since there is no CSS-way to select specific words in a sentence:
<h1><span>Resize</span> and <span>enjoy!</span></h1>And since we will be doing the line wrapping ourselves, it’s important to unset some defaults:
h1 {
position: absolute; /* Keeps the text at the center */
white-space: nowrap; /* Disables line wrapping */
}The transition should work without the base styling, but it’s just too plain-looking. They are below if you want to copy them onto your stylesheet:
And just as a recap, our current hack looks like this:
@property --100vw {
syntax: "<length>";
initial-value: 0px;
inherits: false;
}
:root {
--100vw: 100vw;
--int-width: calc(10000 * tan(atan2(var(--100vw), 10000px)));
--lower-bound: 400;
--upper-bound: 1200;
--wideness: calc(
(clamp(var(--lower-bound), var(--int-width), var(--upper-bound)) - var(--lower-bound)) / (var(--upper-bound) - var(--lower-bound))
);
}OK, enough with the set-up. It’s time to use our new values and make the viewport transition. We first gotta identify how the title should be rearranged for smaller screens: as you saw in the initial demo, the first span goes up and right, while the second span does the opposite and goes down and left. So, the end position for both spans translates to the following values:
h1 {
span:nth-child(1) {
display: inline-block; /* So transformations work */
position: relative;
bottom: 1.2lh;
left: 50%;
transform: translate(-50%);
}
span:nth-child(2) {
display: inline-block; /* So transformations work */
position: relative;
bottom: -1.2lh;
left: -50%;
transform: translate(50%);
}
}Before going forward, both formulas are basically the same, but with different signs. We can rewrite them at once bringing one new variable: --direction. It will be either 1 or -1 and define which direction to run the transition:
h1 {
span {
display: inline-block;
position: relative;
bottom: calc(1.2lh * var(--direction));
left: calc(50% * var(--direction));
transform: translate(calc(-50% * var(--direction)));
}
span:nth-child(1) {
--direction: 1;
}
span:nth-child(2) {
--direction: -1;
}
}
The next step would be bringing --wideness into the formula so that the values change as the screen resizes. However, we can’t just multiply everything by --wideness. Why? Let’s see what happens if we do:
span {
display: inline-block;
position: relative;
bottom: calc(var(--wideness) * 1.2lh * var(--direction));
left: calc(var(--wideness) * 50% * var(--direction));
transform: translate(calc(var(--wideness) * -50% * var(--direction)));
}As you’ll see, everything is backwards! The words wrap when the screen is too wide, and unwrap when the screen is too narrow:
Unlike our first examples, in which the transition ends as --wideness increases from 0 to 1, we want to complete the transition as --wideness decreases from 1 to 0, i.e. while the screen gets smaller the properties need to reach their end value. This isn’t a big deal, as we can rewrite our formula as a subtraction, in which the subtracting number gets bigger as --wideness increases:
span {
display: inline-block;
position: relative;
bottom: calc((1.2lh - var(--wideness) * 1.2lh) * var(--direction));
left: calc((50% - var(--wideness) * 50%) * var(--direction));
transform: translate(calc((-50% - var(--wideness) * -50%) * var(--direction)));
}And now everything moves in the right direction while resizing the screen!
However, you will notice how words move in a straight line and some words overlap while resizing. We can’t allow this since a user with a specific screen size may get stuck at that point in the transition. Viewport transitions are cool, but not at the expense of ruining the experience for certain screen sizes.
Instead of moving in a straight line, words should move in a curve such that they pass around the central word. Don’t worry, making a curve here is easier than it looks: just move the spans twice as fast in the x-axis as they do in the y-axis. This can be achieved by multiplying --wideness by 2, although we have to cap it at 1 so it doesn’t overshoot past the final value.
span {
display: inline-block;
position: relative;
bottom: calc((1.2lh - var(--wideness) * 1.2lh) * var(--direction));
left: calc((50% - min(var(--wideness) * 2, 1) * 50%) * var(--direction));
transform: translate(calc((-50% - min(var(--wideness) * 2, 1) * -50%) * var(--direction)));
}Look at that beautiful curve, just avoiding the central text:
It’s surprising how powerful having the viewport as an integer can be, and what’s even crazier, the last example is one of the most basic transitions you could make with this typecasting hack. Once you do the initial setup, I can imagine a lot more possible transitions, and --widenesss is so useful, it’s like having a new CSS feature right now.
I expect to see more about “Viewport Transitions” in the future because they do make websites feel more “alive” than adaptive.
Typecasting and Viewport Transitions in CSS With tan(atan2()) originally published on CSS-Tricks, which is part of the DigitalOcean family. You should get the newsletter.
The rollout of 5G networks marks a very big step in technology evolution. With its promise of faster speeds, ultra-low latency, and enhanced connectivity, 5G is transforming how businesses operate and individuals access technology. The field that is set to gain from this greatly is SaaS or Software as a Service.
Modern business cannot be imagined without SaaS applications. Everything from customer service to data management support is available in SaaS applications. Therefore, 5G brings improvements in performance, accessibility, and the adoption of SaaS applications. What impact does 5G have on SaaS applications, the benefits it brings, the challenges it faces, and the implications for future business operations are all discussed here in this blog.
5G, which is the fifth generation of wireless technology, comes with much better features as compared to the previous generation that is 4G. It has a much better data transfer rate and a low latency level in comparison with the 4G. A much larger number of devices can be connected compared to 4G. Such advances are much in demand for technologies like IoT, AR, and AI-driven platforms.
SaaS is a model of cloud computing software delivery wherein applications are provided on remote servers and accessed via the Internet. The difference between traditional software, which requires installation on local devices, is that SaaS is a fully online software delivery model. It is thus flexible and eliminates hardware costs.
Examples of popular SaaS applications include Google Workspace, Salesforce, and Zoom, which have revolutionized businesses in their mode of operations.
5G improves the speed of data transfer significantly. SaaS applications, which usually involve large datasets exchange, are highly benefited by this improvement. File uploads, real-time collaboration, and data synchronization become faster and more efficient.
Low latency ensures minimal delays in communication, making 5G ideal for real-time SaaS applications. This is especially crucial for industries where time-sensitive decisions are essential, such as telemedicine, live trading, or customer support.
With 5G, mobility of mobile users in accessing SaaS applications even in transit and in remote places will be without disruptions. In general, mobility helps industries with logistics, sales, and field services.
5G supports simultaneous connections of numerous devices, thereby improving SaaS platforms that rely on IoT. This enables real-time data collection, automation, and better device management.
SaaS platforms are usually challenged during peak traffic. 5G ensures that platforms are reliable even in case of high volumes of users, which means a better experience for the end user.
The COVID-19 pandemic sped up the demand for remote work tools such as Slack, Zoom, and Asana. 5G enables applications that were earlier unable to work at all due to historically poor connectivity in many areas. This keeps businesses productive regardless of location.
Many organizations have resisted the adoption of SaaS mainly because of connectivity issues.5G removes the fear as connectivity is now reliable, fast, and stable, meaning that organizations can change to cloud without any hitches.
5G opens up SaaS applications to run large data inputs in real time, thus promoting AI-based solutions. According to recent software development statistics, AI-driven SaaS tools are witnessing significant adoption across industries, improving automation and decision-making processes. These tools generate insights, automates repetitive tasks, and provides a unique user experience.
The infrastructure for widespread SaaS adoption is usually lacking in emerging markets. 5G wireless connectivity fills this gap, making cloud-based solutions more accessible in regions with limited broadband availability.
Although the integration of 5G with SaaS has its benefits, it also presents some challenges:
The 5G infrastructure is a very capital-intensive activity. For companies and regions with very tight budgets, this slows down adoption.
The faster connectivity and more devices connected mean that the risk of cyberattacks increases. SaaS providers need to implement robust security measures, such as encryption and multi-factor authentication, to protect user data.
Older devices and systems do not support 5G, and hence, businesses have to invest in hardware upgrades.
5G rollout is uneven across regions, creating disparities in access to its benefits. Businesses in some places may not have access to the benefits brought about by 5G.
The 5G low-latency and high-speed ability allows telemedicine platforms to undertake real-time video consultations and remote monitoring of patients.
E-learning platforms can stream interactive and high-quality content without buffering, hence offering a better experience for the students.
5G supports a personalized shopping experience, real-time inventory tracking, and seamless payment processing for online merchants.
IoT-enabled SaaS platforms also enable the real-time monitoring and control of machines and production processes.
Real-time analytics and predictive automation could be monitored on SaaS platforms because of the speed and connectivity of 5G to take an informed decision at every level of a business.
5G would enable SaaS platforms to implement augmented and virtual reality in sectors like real estate, gaming, and retail.
With IoT and SaaS platforms based on 5G, the urban infrastructure would include better energy management, traffic flow, and public safety.
The quicker response time and no lagging performance would make the user experience better, and SaaS would become a must-have for organizations.
Introduction to 5G SaaS applications is a game-changer as it increases performance, reliability, and accessibility while it boosts speeds, lowers latency, and raises bandwidth. Possibilities now lie open for health and education to manufacturing and retail industries.
However, with extreme price and security issues and uneven global deployment, much is still in store so that the full potential of 5G can be delivered. The more businesses take on further adoption in terms of 5G, the faster they would be in their pace of innovating and facilitating greater efficiency and scalability.
The post The Impact of 5G on SaaS Application Performance and Adoption appeared first on noupe.
Some Amazon app users are noticing a new design, with the navigation bar and the company logo now missing. Instead, a large search bar greet users, raising questions about whether this change is part of a broader redesign or a test for a future logo-less interface.
I’m trying to come up with ways to make components more customizable, more efficient, and easier to use and understand, and I want to describe a pattern I’ve been leaning into using CSS Cascade Layers.
I enjoy organizing code and find cascade layers a fantastic way to organize code explicitly as the cascade looks at it. The neat part is, that as much as it helps with “top-level” organization, cascade layers can be nested, which allows us to author more precise styles based on the cascade.
The only downside here is your imagination, nothing stops us from over-engineering CSS. And to be clear, you may very well consider what I’m about to show you as a form of over-engineering. I think I’ve found a balance though, keeping things simple yet organized, and I’d like to share my findings.
Let’s explore a pattern for writing components in CSS using a button as an example. Buttons are one of the more popular components found in just about every component library. There’s good reason for that popularity because buttons can be used for a variety of use cases, including:
focus or hover.And buttons come in several different flavors of markup, like , input[type="button"], and . There are even more ways to make buttons than that, if you can believe it.
On top of that, different buttons perform different functions and are often styled accordingly so that a button for one type of action is distinguished from another. Buttons also respond to state changes, such as when they are hovered, active, and focused. If you have ever written CSS with the BEM syntax, we can sort of think along those lines within the context of cascade layers.
.button {}
.button-primary {}
.button-secondary {}
.button-warning {}
/* etc. */Okay, now, let’s write some code. Specifically, let’s create a few different types of buttons. We’ll start with a .button class that we can set on any element that we want to be styled as, well, a button! We already know that buttons come in different flavors of markup, so a generic .button class is the most reusable and extensible way to select one or all of them.
.button {
/* Styles common to all buttons */
}This is where we can insert our very first cascade layer! Remember, the reason we want a cascade layer in the first place is that it allows us to set the CSS Cascade’s reading order when evaluating our styles. We can tell CSS to evaluate one layer first, followed by another layer, then another — all according to the order we want. This is an incredible feature that grants us superpower control over which styles “win” when applied by the browser.
We’ll call this layer components because, well, buttons are a type of component. What I like about this naming is that it is generic enough to support other components in the future as we decide to expand our design system. It scales with us while maintaining a nice separation of concerns with other styles we write down the road that maybe aren’t specific to components.
/* Components top-level layer */
@layer components {
.button {
/* Styles common to all buttons */
}
}Here is where things get a little weird. Did you know you can nest cascade layers inside classes? That’s totally a thing. So, check this out, we can introduce a new layer inside the .button class that’s already inside its own layer. Here’s what I mean:
/* Components top-level layer */
@layer components {
.button {
/* Component elements layer */
@layer elements {
/* Styles */
}
}
}This is how the browser interprets that layer within a layer at the end of the day:
@layer components {
@layer elements {
.button {
/* button styles... */
}
}
}This isn’t a post just on nesting styles, so I’ll just say that your mileage may vary when you do it. Check out Andy Bell’s recent article about using caution with nested styles.
So far, we’ve established a .button class inside of a cascade layer that’s designed to hold any type of component in our design system. Inside that .button is another cascade layer, this one for selecting the different types of buttons we might encounter in the markup. We talked earlier about buttons being , , or and this is how we can individually select style each type.
We can use the :is() pseudo-selector function as that is akin to saying, “If this .button is an element, then apply these styles.”
/* Components top-level layer */
@layer components {
.button {
/* Component elements layer */
@layer elements {
/* styles common to all buttons */
&:is(a) {
/* <a> specific styles */
}
&:is(button) {
/* <button> specific styles */
}
/* etc. */
}
}
}I’m going to fill in our code with the common styles that apply to all buttons. These styles sit at the top of the elements layer so that they are applied to any and all buttons, regardless of the markup. Consider them default button styles, so to speak.
/* Components top-level layer */
@layer components {
.button {
/* Component elements layer */
@layer elements {
background-color: darkslateblue;
border: 0;
color: white;
cursor: pointer;
display: grid;
font-size: 1rem;
font-family: inherit;
line-height: 1;
margin: 0;
padding-block: 0.65rem;
padding-inline: 1rem;
place-content: center;
width: fit-content;
}
}
}What should our default buttons do when they are hovered, clicked, or in focus? These are the different states that the button might take when the user interacts with them, and we need to style those accordingly.
I’m going to create a new cascade sub-layer directly under the elements sub-layer called, creatively, states:
/* Components top-level layer */
@layer components {
.button {
/* Component elements layer */
@layer elements {
/* Styles common to all buttons */
}
/* Component states layer */
@layer states {
/* Styles for specific button states */
}
}
}Pause and reflect here. What states should we target? What do we want to change for each of these states?
Some states may share similar property changes, such as :hover and :focus having the same background color. Luckily, CSS gives us the tools we need to tackle such problems, using the :where() function to group property changes based on the state. Why :where() instead of :is()? :where() comes with zero specificity, meaning it’s a lot easier to override than :is(), which takes the specificity of the element with the highest specificity score in its arguments. Maintaining low specificity is a virtue when it comes to writing scalable, maintainable CSS.
/* Component states layer */
@layer states {
&:where(:hover, :focus-visible) {
/* button hover and focus state styles */
}
}But how do we update the button’s styles in a meaningful way? What I mean by that is how do we make sure that the button looks like it’s hovered or in focus? We could just slap a new background color on it, but ideally, the color should be related to the background-color set in the elements layer.
So, let’s refactor things a bit. Earlier, I set the .button element’s background-color to darkslateblue. I want to reuse that color, so it behooves us to make that into a CSS variable so we can update it once and have it apply everywhere. Relying on variables is yet another virtue of writing scalable and maintainable CSS.
I’ll create a new variable called --button-background-color that is initially set to darkslateblue and then set it on the default button styles:
/* Component elements layer */
@layer elements {
--button-background-color: darkslateblue;
background-color: var(--button-background-color);
border: 0;
color: white;
cursor: pointer;
display: grid;
font-size: 1rem;
font-family: inherit;
line-height: 1;
margin: 0;
padding-block: 0.65rem;
padding-inline: 1rem;
place-content: center;
width: fit-content;
}Now that we have a color stored in a variable, we can set that same variable on the button’s hovered and focused states in our other layer, using the relatively new color-mix() function to convert darkslateblue to a lighter color when the button is hovered or in focus.
Back to our states layer! We’ll first mix the color in a new CSS variable called --state-background-color:
/* Component states layer */
@layer states {
&:where(:hover, :focus-visible) {
/* custom property only used in state */
--state-background-color: color-mix(
in srgb,
var(--button-background-color),
white 10%
);
}
}We can then apply that color as the background color by updating the background-color property.
/* Component states layer */
@layer states {
&:where(:hover, :focus-visible) {
/* custom property only used in state */
--state-background-color: color-mix(
in srgb,
var(--button-background-color),
white 10%
);
/* applying the state background-color */
background-color: var(--state-background-color);
}
}Along with elements and states layers, you may be looking for some sort of variation in your components, such as modifiers. That’s because not all buttons are going to look like your default button. You might want one with a green background color for the user to confirm a decision. Or perhaps you want a red one to indicate danger when clicked. So, we can take our existing default button styles and modify them for those specific use cases
If we think about the order of the cascade — always flowing from top to bottom — we don’t want the modified styles to affect the styles in the states layer we just made. So, let’s add a new modifiers layer in between elements and states:
/* Components top-level layer */
@layer components {
.button {
/* Component elements layer */
@layer elements {
/* etc. */
}
/* Component modifiers layer */
@layer modifiers {
/* new layer! */
}
/* Component states layer */
@layer states {
/* etc. */
}
}Similar to how we handled states, we can now update the --button-background-color variable for each button modifier. We could modify the styles further, of course, but we’re keeping things fairly straightforward to demonstrate how this system works.
We’ll create a new class that modifies the background-color of the default button from darkslateblue to darkgreen. Again, we can rely on the :is() selector because we want the added specificity in this case. That way, we override the default button style with the modifier class. We’ll call this class .success (green is a “successful” color) and feed it to :is():
/* Component modifiers layer */
@layer modifiers {
&:is(.success) {
--button-background-color: darkgreen;
}
}If we add the .success class to one of our buttons, it becomes darkgreen instead darkslateblue which is exactly what we want. And since we already do some color-mix()-ing in the states layer, we’ll automatically inherit those hover and focus styles, meaning darkgreen is lightened in those states.
/* Components top-level layer */
@layer components {
.button {
/* Component elements layer */
@layer elements {
--button-background-color: darkslateblue;
background-color: var(--button-background-color);
/* etc. */
/* Component modifiers layer */
@layer modifiers {
&:is(.success) {
--button-background-color: darkgreen;
}
}
/* Component states layer */
@layer states {
&:where(:hover, :focus) {
--state-background-color: color-mix(
in srgb,
var(--button-background-color),
white 10%
);
background-color: var(--state-background-color);
}
}
}
}We can refactor any CSS property we need to modify into a CSS custom property, which gives us a lot of room for customization.
/* Components top-level layer */
@layer components {
.button {
/* Component elements layer */
@layer elements {
--button-background-color: darkslateblue;
--button-border-width: 1px;
--button-border-style: solid;
--button-border-color: transparent;
--button-border-radius: 0.65rem;
--button-text-color: white;
--button-padding-inline: 1rem;
--button-padding-block: 0.65rem;
background-color: var(--button-background-color);
border:
var(--button-border-width)
var(--button-border-style)
var(--button-border-color);
border-radius: var(--button-border-radius);
color: var(--button-text-color);
cursor: pointer;
display: grid;
font-size: 1rem;
font-family: inherit;
line-height: 1;
margin: 0;
padding-block: var(--button-padding-block);
padding-inline: var(--button-padding-inline);
place-content: center;
width: fit-content;
}
/* Component modifiers layer */
@layer modifiers {
&:is(.success) {
--button-background-color: darkgreen;
}
&:is(.ghost) {
--button-background-color: transparent;
--button-text-color: black;
--button-border-color: darkslategray;
--button-border-width: 3px;
}
}
/* Component states layer */
@layer states {
&:where(:hover, :focus) {
--state-background-color: color-mix(
in srgb,
var(--button-background-color),
white 10%
);
background-color: var(--state-background-color);
}
}
}
}P.S. Look closer at that demo and check out how I’m adjusting the button’s background using light-dark() — then go read Sara Joy’s “Come to the light-dark() Side” for a thorough rundown of how that works!
What do you think? Is this something you would use to organize your styles? I can see how creating a system of cascade layers could be overkill for a small project with few components. But even a little toe-dipping into things like we just did illustrates how much power we have when it comes to managing — and even taming — the CSS Cascade. Buttons are deceptively complex but we saw how few styles it takes to handle everything from the default styles to writing the styles for their states and modified versions.
Organizing Design System Component Patterns With CSS Cascade Layers originally published on CSS-Tricks, which is part of the DigitalOcean family. You should get the newsletter.
