You’ve played Flexbox Froggy before, right? Or maybe Grid Garden? They’re both absolute musts for learning the basics of modern CSS layout using Flexbox and CSS Grid. I use both games in all of the classes I teach and I never get anything but high-fives from my students because they love them so much.
Thomas wrote in to share his latest game with us: Anchoreum.
I’ll bet the two nickels in my pocket that you know this game’s all about CSS Anchor Positioning. I love that Thomas has jumped on this so quickly because the feature is still fresh, and indeed is currently only supported in a couple of browsers at the moment.
This is the perfect time to learn about anchor positioning. It’s still relatively early days, but things are baked enough to be supported in Chrome and Edge so you can access the games. If you haven’t seen Juan’s big ol’ guide on anchor positioning, that’s another dandy way to get up to speed.
The objective is less on-the-nose than Flexbox Froggy and Grid Garden, which both lean heavily into positioning elements to complete game tasks. For example, Flexbox Froggy is about positioning frogs safely on lilypads. Grid Garden wants you to water specific garden areas to feed your carrots. Anchoreum? You’re in a museum and need to anchor labels to museum artifacts. I know, attaching target elements to the same anchor over and again could get boring. But thankfully the game goes beyond simple positioning by getting into multiple anchors, spanning, and position fallbacks.
Whatever the objective, the repetition is good for developing muscle memory and the overall outcome is still the same: learn CSS Anchor Positioning. I’m already planning how and where I’m going to use Anchoreum in my curriculum. It’s not often we get a fun interactive learning resource like this for such a new web feature and I think it’s worth jumping on it sooner rather than later.
Thomas prepped a video trailer for the game so I thought I’d drop that for reference.
Another title from A Book Apart has been re-released for free. The latest? Tim Brown’s Flexible Typesetting. I may not be the utmost expert on typography and its best practices but I do remember reading this book (it’s still on the shelf next to me!) thinking maybe, just maybe, I might be able to hold a conversation about it with Robin when I finished it.
I still think I’m in “maybe” territory but that’s not Tim’s fault — I found the book super helpful and approachable for noobs like me who want to up our game. For the sake of it, I’ll drop the chapter titles here to give you an idea of what you’ll get.
What is typsetting?
Preparing text and code (planning is definitely part of the typesetting process)
Selecting typefaces (this one helped me a lot!)
Shaping text blocks (modern CSS can help here)
Crafting compositions (great if you’re designing for long-form content)
Fear not, for this guide will arm you with the tools and humor needed to navigate these meetings with style (and sanity) intact.
1. Master Your Facial Expressions
First things first: when the client says, “Can you make it pop?”, your face is a canvas that needs to remain as neutral as Helvetica.
Resist the urge to roll your eyes so hard they’re at risk of orbiting the sun. Instead, master the subtle nod paired with a thoughtful “Hmm,” as if you’re a wise sage deciphering the mysteries of the universe.
Pro tip: Practice in front of the mirror so your face says, “I’m intrigued,” instead of “I’m Googling how to change careers.”
2. Decode the Pop Factor
What does “pop” mean? Good question! No one knows. In fact, ‘pop’ is a cryptid, somewhere between Bigfoot and the Loch Ness Monster in terms of actual sightings.
But that won’t stop clients from using it like it’s on page one of the design manual.
Here are a few common translations of ‘pop’:
Make it brighter: Double-check that your design isn’t already capable of blinding astronauts. If not, unleash a palette of neon.
Add more contrast: Prepare to juggle gradients and shadows like a circus act.
Something ‘fun’: Add confetti! No one can complain about confetti.
3. The Color Gauntlet
When a client asks for “more pop,” 99% of the time they want color. Lots of it. The kind of color that makes you question your entire aesthetic sensibility. You might have envisioned a clean, minimalist layout—something that whispers sophistication.
But now you need to bring in more saturated hues than a ’80s fashion show.
Your strategy: Open your design software, set your color wheel to “Unleash Chaos,” and make peace with the fact that subtlety is no longer in the building.
4. Add Unnecessary Sparkle
If things start to go south and the client still looks unconvinced, here’s a designer secret: add a glow, shimmer, or ‘futuristic’ shine.
The magic of unnecessary sparkles is that clients often don’t know what they want until they see something that distracts them long enough to forget their original request.
Disclaimer: Excessive sparkles may lead to existential questioning of your career choices.
5. The “Just One More Thing” Loop
Once you’ve ‘popped’ the design to within an inch of its life, the client will inevitably say, “It’s great, but can you add just one more thing?” This is a pivotal moment where you must embrace your inner zen master.
Mental exercise: Picture yourself as a superhero whose only power is to smile and say, “Of course!” while internally questioning how many ‘one more things’ it takes to reach creative enlightenment.
6. The Great Font Debate
If your design involves text, prepare for the client to request that the headline “pop” more. Suddenly, every typeface you suggest will be compared to a distant cousin’s wedding invite or an obscure 1992 music festival poster. And just when you think you’ve found the perfect font, they’ll say, “Can we try Comic Sans?”
Response: Take a deep breath, channel your best customer service voice, and gently guide them away from the abyss.
7. When All Else Fails, Add an Exclamation Point!
Nothing says “pop” quite like adding an exclamation point to everything. Your client might not know why it works, but they’ll be convinced it does.
It’s the design equivalent of yelling, “Ta-da!” after revealing a trick.
Conclusion
At the end of the day, remember that “popping” is an art form, a mystical dance between client expectations and your creative limits.
Sometimes, it means finding that perfect middle ground between tasteful and tacky. Other times, it means letting go and accepting that your carefully crafted layout now resembles a carnival flyer.
Smile, nod, and don’t forget—you’re not just a designer. You’re a magician, conjuring bursts of color, sparkle, and fonts into creations that ‘pop’ just enough to keep everyone happy—or at least not asking for Comic Sans again.
It’s easy to default to what you know. When it comes to toggling content, that might be reaching for display: none or opacity: 0 with some JavaScript sprinkled in. But the web is more “modern” today, so perhaps now is the right time to get a birds-eye view of the different ways to toggle content — which native APIs are actually supported now, their pros and cons, and some things about them that you might not know (such as any pseudo-elements and other non-obvious stuff).
So, let’s spend some time looking at disclosures (
and ), the Dialog API, the Popover API, and more. We’ll look at the right time to use each one depending on your needs. Modal or non-modal? JavaScript or pure HTML/CSS? Not sure? Don’t worry, we’ll go into all that.
Disclosures ( and )
Use case: Accessibly summarizing content while making the content details togglable independently, or as an accordion.
CodePen Embed Fallback
Going in release order, disclosures — known by their elements as
and — marked the first time we were able to toggle content without JavaScript or weird checkbox hacks. But lack of web browser support obviously holds new features back at first, and this one in particular came without keyboard accessibility. So I’d understand if you haven’t used it since it came to Chrome 12 way back in 2011. Out of sight, out of mind, right?
Here’s the low-down:
It’s functional without JavaScript (without any compromises).
It’s fully stylable without appearance: none or the like.
You can hide the marker without non-standard pseudo-selectors.
You can connect multiple disclosures to create an accordion.
Aaaand… it’s fully animatable, as of 2024.
Marking up disclosures
What you’re looking for is this:
<details>
<summary>Content summary (always visible)</summary>
Content (visibility is toggled when summary is clicked on)
</details>
Behind the scenes, the content’s wrapped in a pseudo-element that as of 2024 we can select using ::details-content. To add to this, there’s a ::marker pseudo-element that indicates whether the disclosure’s open or closed, which we can customize.
With that in mind, disclosures actually look like this under the hood:
<details>
<summary><::marker></::marker>Content summary (always visible)</summary>
<::details-content>
Content (visibility is toggled when summary is clicked on)
</::details-content>
</details>
To have the disclosure open by default, give
the open attribute, which is what happens behind the scenes when disclosures are opened anyway.
<details open> ... </details>
Styling disclosures
Let’s be real: you probably just want to lose that annoying marker. Well, you can do that by setting the display property of
to anything but list-item:
summary {
display: block; /* Or anything else that isn't list-item */
}
CodePen Embed Fallback
Alternatively, you can modify the marker. In fact, the example below utilizes Font Awesome to replace it with another icon, but keep in mind that ::marker doesn’t support many properties. The most flexible workaround is to wrap the content of
details {
/* The marker */
summary::marker {
content: "f150";
font-family: "Font Awesome 6 Free";
}
/* The marker when <details> is open */
&[open] summary::marker {
content: "f151";
}
/* Because ::marker doesn’t support many properties */
summary span {
margin-left: 1ch;
display: inline-block;
}
}
CodePen Embed Fallback
Creating an accordion with multiple disclosures
CodePen Embed Fallback
To create an accordion, name multiple disclosures (they don’t even have to be siblings) with a name attribute and a matching value (similar to how you’d implement ):
<details name="starWars" open>
<summary>Prequels</summary>
<ul>
<li>Episode I: The Phantom Menace</li>
<li>Episode II: Attack of the Clones</li>
<li>Episode III: Revenge of the Sith</li>
</ul>
</details>
<details name="starWars">
<summary>Originals</summary>
<ul>
<li>Episode IV: A New Hope</li>
<li>Episode V: The Empire Strikes Back</li>
<li>Episode VI: Return of the Jedi</li>
</ul>
</details>
<details name="starWars">
<summary>Sequels</summary>
<ul>
<li>Episode VII: The Force Awakens</li>
<li>Episode VIII: The Last Jedi</li>
<li>Episode IX: The Rise of Skywalker</li>
</ul>
</details>
Using a wrapper, we can even turn these into horizontal tabs:
If you’re looking for some wild ideas on what we can do with the Popover API in CSS, check out John Rhea’s article in which he makes an interactive game solely out of disclosures!
Adding JavaScript functionality
Want to add some JavaScript functionality?
// Optional: select and loop multiple disclosures
document.querySelectorAll("details").forEach(details => {
details.addEventListener("toggle", () => {
// The disclosure was toggled
if (details.open) {
// The disclosure was opened
} else {
// The disclosure was closed
}
});
});
Creating accessible disclosures
Disclosures are accessible as long as you follow a few rules. For example,
is basically a , meaning that its content is announced by screen readers when in focus. If there isn’t a or isn’t a direct child of then the user agent will create a label for you that normally says “Details” both visually and in assistive tech. Older web browsers might insist that it be the first child, so it’s best to make it so.
To add to this,
has the role of button, so whatever’s invalid inside a is also invalid inside a . This includes headings, so you can style a as a heading, but you can’t actually insert a heading into a .
The Dialog element ()
Use case: Modals
CodePen Embed Fallback
Now that we have the Popover API for non-modal overlays, I think it’s best if we start to think of dialogs as modals even though the show() method does allow for non-modal dialogs. The advantage that the popover attribute has over the element is that you can use it to create non-modal overlays without JavaScript, so in my opinion there’s no benefit to non-modal dialogs anymore, which do require JavaScript. For clarity, a modal is an overlay that makes the main document inert, whereas with non-modal overlays the main document remains interactive. There are a few other features that modal dialogs have out-of-the-box as well, including:
a stylable backdrop,
an autofocus onto the first focusable element within the (or, as a backup, the itself — include an aria-label in this case),
a focus trap (as a result of the main document’s inertia),
the esc key closes the dialog, and
both the dialog and the backdrop are animatable.Marking up and activating dialogs
Start with the element:
<dialog> ... </dialog>
It’s hidden by default and, similar to
, we can have it open when the page loads, although it isn’t modal in this scenario since it does not contain interactive content because it doesn’t opened with showModal().
<dialog open> ... </dialog>
I can’t say that I’ve ever needed this functionality. Instead, you’ll likely want to reveal the dialog upon some kind of interaction, such as the click of a button — so here’s that button:
Wait, why are we using data attributes? Well, because we might want to hand over an identifier that tells the JavaScript which dialog to open, enabling us to add the dialog functionality to all dialogs in one snippet, like this:
// Select and loop all elements with that data attribute
document.querySelectorAll("[data-dialog]").forEach(button => {
// Listen for interaction (click)
button.addEventListener("click", () => {
// Select the corresponding dialog
const dialog = document.querySelector(`#${ button.dataset.dialog }`);
// Open dialog
dialog.showModal();
// Close dialog
dialog.querySelector(".closeDialog").addEventListener("click", () => dialog.close());
});
});
Don’t forget to add a matching id to the so it’s associated with the that shows it:
<dialog id="dialogA"> <!-- id and data-dialog = dialogA --> ... </dialog>
Note: (that has a ) or (wrapped in a ) also closes the dialog.
How to prevent scrolling when the dialog is open
Prevent scrolling while the modal’s open, with one line of CSS:
body:has(dialog:modal) { overflow: hidden; }
Styling the dialog’s backdrop
And finally, we have the backdrop to reduce distraction from what’s underneath the top layer (this applies to modals only). Its styles can be overwritten, like this:
::backdrop {
background: hsl(0 0 0 / 90%);
backdrop-filter: blur(3px); /* A fun property just for backdrops! */
}
On that note, the itself comes with a border, a background, and some padding, which you might want to reset. Actually, popovers behave the same way.
Dealing with non-modal dialogs
To implement a non-modal dialog, use:
show() instead of showModal()
dialog[open] (targets both) instead of dialog:modal
Although, as I said before, the Popover API doesn’t require JavaScript, so for non-modal overlays I think it’s best to use that.
The Popover API ()
Use case: Non-modal overlays
CodePen Embed Fallback
Popups, basically. Suitable use cases include tooltips (or toggletips — it’s important to know the difference), onboarding walkthroughs, notifications, togglable navigations, and other non-modal overlays where you don’t want to lose access to the main document. Obviously these use cases are different to those of dialogs, but nonetheless popovers are extremely awesome. Functionally they’re just like just dialogs, but not modal and don’t require JavaScript.
Marking up popovers
To begin, the popover needs an id as well as the popover attribute with the manual value (which means clicking outside of the popover doesn’t close it), the auto value (clicking outside of the popover does close it), or no value (which means the same thing). To be semantic, the popover can be a .
<dialog id="tooltipA" popover> ... </dialog>
Next, add the popovertarget attribute to the or that we want to toggle the popover’s visibility, with a value matching the popover’s id attribute (this is optional since clicking outside of the popover will close it anyway, unless popover is set to manual):
Place another one of those buttons in your main document, so that you can show the popover. That’s right, popovertarget is actually a toggle (unless you specify otherwise with the popovertargetaction attribute that accepts show, hide, or toggle as its value — more on that later).
Styling popovers
CodePen Embed Fallback
By default, popovers are centered within the top layer (like dialogs), but you probably don’t want them there as they’re not modals, after all.
You can easily pull them into a corner using fixed positioning, but for a tooltip-style popover you’d want it to be relative to the trigger that opens it. CSS Anchor Positioning makes this super easy:
main [popovertarget] {
anchor-name: --trigger;
}
[popover] {
margin: 0;
position-anchor: --trigger;
top: calc(anchor(bottom) + 10px);
justify-self: anchor-center;
}
/* This also works but isn’t needed
unless you’re using the display property
[popover]:popover-open {
...
}
*/
The problem though is that you have to name all of these anchors, which is fine for a tabbed component but overkill for a website with quite a few tooltips. Luckily, we can match an id attribute on the button to an anchor attribute on the popover, which isn’t well-supported as of November 2024 but will do for this demo:
CodePen Embed Fallback
<main>
<!-- The id should match the anchor attribute -->
<button id="anchorA" popovertarget="tooltipA">Show tooltipA</button>
<button id="anchorB" popovertarget="tooltipB">Show tooltipB</button>
</main>
<dialog anchor="anchorA" id="tooltipA" popover>
<button popovertarget="tooltipA">Hide tooltipA</button>
</dialog>
<dialog anchor="anchorB" id="tooltipB" popover>
<button popovertarget="tooltipB">Hide tooltipB</button>
</dialog>
main [popovertarget] { anchor-name: --anchorA; } /* No longer needed */
[popover] {
margin: 0;
position-anchor: --anchorA; /* No longer needed */
top: calc(anchor(bottom) + 10px);
justify-self: anchor-center;
}
The next issue is that we expect tooltips to show on hover and this doesn’t do that, which means that we need to use JavaScript. While this seems complicated considering that we can create tooltips much more easily using ::before/::after/content:, popovers allow HTML content (in which case our tooltips are actually toggletips by the way) whereas content: only accepts text.
Adding JavaScript functionality
Which leads us to this…
CodePen Embed Fallback
Okay, so let’s take a look at what’s happening here. First, we’re using anchor attributes to avoid writing a CSS block for each anchor element. Popovers are very HTML-focused, so let’s use anchor positioning in the same way. Secondly, we’re using JavaScript to show the popovers (showPopover()) on mouseover. And lastly, we’re using JavaScript to hide the popovers (hidePopover()) on mouseout, but not if they contain a link as obviously we want them to be clickable (in this scenario, we also don’t hide the button that hides the popover).
<main>
<button id="anchorLink" popovertarget="tooltipLink">Open tooltipLink</button>
<button id="anchorNoLink" popovertarget="tooltipNoLink">Open tooltipNoLink</button>
</main>
<dialog anchor="anchorLink" id="tooltipLink" popover>Has <a href="#">a link</a>, so we can’t hide it on mouseout
<button popovertarget="tooltipLink">Hide tooltipLink manually</button>
</dialog>
<dialog anchor="anchorNoLink" id="tooltipNoLink" popover>Doesn’t have a link, so it’s fine to hide it on mouseout automatically
<button popovertarget="tooltipNoLink">Hide tooltipNoLink</button>
</dialog>
/* Select and loop all popover triggers */
document.querySelectorAll("main [popovertarget]").forEach((popovertarget) => {
/* Select the corresponding popover */
const popover = document.querySelector(`#${popovertarget.getAttribute("popovertarget")}`);
/* Show popover on trigger mouseover */
popovertarget.addEventListener("mouseover", () => {
popover.showPopover();
});
/* Hide popover on trigger mouseout, but not if it has a link */
if (popover.matches(":not(:has(a))")) {
popovertarget.addEventListener("mouseout", () => {
popover.hidePopover();
});
}
});
At first, I was sure that popovers having backdrops was an oversight, the argument being that they shouldn’t obscure a focusable main document. But maybe it’s okay for a couple of seconds as long as we can resume what we were doing without being forced to close anything? At least, I think this works well for a set of onboarding tips:
CodePen Embed Fallback
<!-- Re-showing ‘A’ rolls the onboarding back to that step -->
<button popovertarget="onboardingTipA" popovertargetaction="show">Restart onboarding</button>
<!-- Hiding ‘A’ also hides subsequent tips as long as the popover attribute equates to auto -->
<button popovertarget="onboardingTipA" popovertargetaction="hide">Cancel onboarding</button>
<ul>
<li id="toolA">Tool A</li>
<li id="toolB">Tool B</li>
<li id="toolC">Another tool, “C”</li>
<li id="toolD">Another tool — let’s call this one “D”</li>
</ul>
<!-- onboardingTipA’s button triggers onboardingTipB -->
<dialog anchor="toolA" id="onboardingTipA" popover>
onboardingTipA <button popovertarget="onboardingTipB" popovertargetaction="show">Next tip</button>
</dialog>
<!-- onboardingTipB’s button triggers onboardingTipC -->
<dialog anchor="toolB" id="onboardingTipB" popover>
onboardingTipB <button popovertarget="onboardingTipC" popovertargetaction="show">Next tip</button>
</dialog>
<!-- onboardingTipC’s button triggers onboardingTipD -->
<dialog anchor="toolC" id="onboardingTipC" popover>
onboardingTipC <button popovertarget="onboardingTipD" popovertargetaction="show">Next tip</button>
</dialog>
<!-- onboardingTipD’s button hides onboardingTipA, which in-turn hides all tips -->
<dialog anchor="toolD" id="onboardingTipD" popover>
onboardingTipD <button popovertarget="onboardingTipA" popovertargetaction="hide">Finish onboarding</button>
</dialog>
/*
After users have had a couple of
seconds to breathe, start the onboarding
*/
setTimeout(() => {
document.querySelector("#onboardingTipA").showPopover();
}, 2000);
Again, let’s unpack. Firstly, setTimeout() shows the first onboarding tip after two seconds. Secondly, a simple fade-in-fade-out background animation runs on the backdrop and all subsequent backdrops. The main document isn’t made inert and the backdrop doesn’t persist, so attention is diverted to the onboarding tips while not feeling invasive.
Thirdly, each popover has a button that triggers the next onboarding tip, which triggers another, and so on, chaining them to create a fully HTML onboarding flow. Typically, showing a popover closes other popovers, but this doesn’t appear to be the case if it’s triggered from within another popover. Also, re-showing a visible popover rolls the onboarding back to that step, and, hiding a popover hides it and all subsequent popovers — although that only appears to work when popover equates to auto. I don’t fully understand it but it’s enabled me to create “restart onboarding” and “cancel onboarding” buttons.
With just HTML. And you can cycle through the tips using esc and return.
Creating modal popovers
Hear me out. If you like the HTML-ness of popover but the semantic value of , this JavaScript one-liner can make the main document inert, therefore making your popovers modal:
However, the popovers must come after the main document; otherwise they’ll also become inert. Personally, this is what I’m doing for modals anyway, as they aren’t a part of the page’s content.
<body>
<!-- All of this will become inert -->
</body>
<!-- Therefore, the modals must come after -->
<dialog popover> ... </dialog>
Aaaand… breathe
Yeah, that was a lot. But…I think it’s important to look at all of these APIs together now that they’re starting to mature, in order to really understand what they can, can’t, should, and shouldn’t be used for. As a parting gift, I’ll leave you with a transition-enabled version of each API:
The requirement of safeguarding original presentation designs has never been more crucial as presentations get increasingly interactive, visually appealing, and indispensable in both corporate and creative domains. Your work is valuable, whether you are a tech entrepreneur creating software that changes the way presentations are done or a designer creating fresh slide decks for customers.
It also needs protection, much as any great asset.
Intellectual Property (IP) laws offer the legal structure to protect your ideas. From safeguarding the visual components of your presentation to ensuring the functionality of your program, IP techniques guarantee that your works remain yours—and stop others from replicating or profitably using them without your permission.
In this post, we will explore several IP techniques creators could apply to guard their original presentation ideas. We will go over how trade secrets, copyrights, trademarks, and patents might help you protect your work. We will also discuss how engaging with a patenting legal firm might enable you to negotiate the complexity of IP legislation to provide the best protection for your presentation designs.
Knowing Copyright Protection for Presentation Designs
Regarding presentations, copyright law is among the most often used kinds of protection available. Copyrights are perfect for protecting the design elements in a presentation since they guard original works of authorship, including written and graphic materials.
What Copyright Protection Offers for Current Design Projects?
Copyright instantly protects your unique work, whether you make a presentation—a creative portfolio, a visually appealing instructional tool, or a set of slides for a commercial pitch. This implies that without your permission, the images, text, layout, and even some design decisions in your presentation cannot be lawfully duplicated or used by others.
For instance, copyright law guards the bespoke illustrations you have created for your slides. Should someone else attempt to use them for their own presentation without your permission, you are entitled to legal action to stop them.
Protection of copyright does not, however, cover the concept underlying your presentation. For example, even if copyright guards the particular design and substance of your slides, it does not stop others from presenting with a related idea or theme.
How might you strengthen your protection of copyright?
Although protection of copyright is automatic the minute you produce your work, it is advisable to register your presentation with the relevant copyright office. The U.S. Copyright Office would handle this in the United States. Not only does registering your work improve your legal position in case of infringement, but it also enables you to ask court for statutory damages should your rights be violated.
Creating a plan for registering your presentations and other visual works can help designers and artists who often generate high-value content add even more security, therefore safeguarding their intellectual property over time.
Patents: Guarding Novel Presentation Devices
Although copyright guards the linguistic and graphic components of your presentation, patents guard any new technology or technique you create or improve upon to use in presentations.
Maintaining your competitive advantage may depend critically on obtaining a patent if your innovation is a tool or program offering a fresh approach to design, delivery, or interaction with presentations.
In the realm of presentational design, what is patentable?
Patents are meant to safeguard innovations; hence, the particular tools or techniques you create for presenting will be qualified for patent protection. These developments might be patentable, for example, if you have built a new software feature allowing users to edit images in a totally different manner during presentations or if you have established a novel interactive means of moving between slides.
For developers building presentable platforms or apps with distinctive capabilities, software patents might be especially valuable. With a patent, you have exclusive rights to commercialize your exclusive technology and guarantee that no one else may use or replicate it without permission.
Patenting Law Firms: Their Function
Especially for authors who might not be aware of the nuances of IP law, navigating the world of patents can be challenging. Working with a good patent law firm guarantees that your application is filed appropriately and that your idea satisfies legal criteria for patentability.
A patent attorney can help you negotiate the patent search process to guarantee that your invention is original. They will also assist in developing a strong patent application with a precise definition of the uniqueness and worth of your innovation. Avoiding typical mistakes that can result in patent rejections or upcoming conflicts depends on this legal knowledge.
Building and safeguarding your presentational brand: Trademarks
Although copyrights and patents defend the content and functionality of your presentation designs, trademarks are absolutely vital for preserving the brand identification of your presentations or the tools you use to produce them.
Using trademark law will help you safeguard the name, logo, and any other unique marks of your company whether you are creating a presentation software platform or marketing presentation design services.
What unique qualities might help your presentation? Business trademarks guard the symbols, names, and other markers that set your business apart from competitors on the market.
Registration of a trademark guarantees that no other company may use the same or a confusingly similar mark whether you have created a distinctive name for your presentation software or use a specific logo to market your design services.
You can register these as trademarks, for instance, if you established a design company concentrating on custom presentations for business clients and your company’s name or logo has become known in the field. This offers you special rights to use them in relation to your offerings and helps to stop rivals from confusing brands by applying a similar name or design.
Maximizing Trademarks for IP Protection and Marketing
Trademarks are a great marketing tool in addition to shielding your brand from copy-offering. Particularly in creative sectors like design, a well-known trademark helps consumers link your products with quality and creativity, therefore guiding their associations. Your brand’s reputation will grow more robust the more obvious and distinctive your trademark is, therefore fostering client loyalty and enabling you to stand out in a crowded market.
Registering your brand with the relevant government agency, including the U.S. Patent and brand Office (USPTO), helps to guard it. Stronger legal rights and simpler enforcement of those rights are obtained from a registered trademark should someone else attempt to use the name or logo of your brand without authorization.
Furthermore trademarks are oftentimes quite valuable assets in licensing agreements. Having a registered trademark lets you license your brand to other businesses while keeping control over how your name is utilized should your presentation tools or design tools go popular.
This can open fresh income sources and increase the visibility of your business.
Trade Secrets: Maintaining Confidentiality about Own Procedures
Certain facets of presentation design—especially proprietary techniques or methods—may be best kept trade secrets. Trade secrets remain private, unlike patents, which demand public disclosure, therefore safeguarding the material for as long as it is not shared.
When should one use trade secrets in reference to presentation designs?
Keeping this knowledge as a trade secret would be the wisest course of action if your design company has established a particular methodology or procedure that provides you a competitive edge, such a proprietary way for building interactive presentations or a workflow that substantially lowers design time. Trade secrets guard the private data of your company without having to register formally for intellectual property rights.
For instance, suppose your company has created a special technique for expediting the design process, enabling you to show excellent presentations ahead of rivals. Protecting this technique as a trade secret will help you instead of patenting it, which would have you reveal how it operates. This helps you to keep your competitive edge as long as the procedure is kept private inside your business.
Effective Protection of Trade Secrets
Maintaining trade secrets calls for tight control of your own procedures. This covers putting confidentiality agreements into effect with partners, contractors, and staff members who handle private data. Verify that any important procedures, tools, or client information is kept safe and only distributed to those who absolutely must know.
Having legal agreements in place helps you to defend your rights in the case of a trade secret breach—that is, when a former employee shares your patented method with a competitor.
Combining IP Approaches for All-around Protection
Although every type of intellectual property (IP) protection—copyrights, patents, trademarks, and trade secrets—serves a different use—combining them will provide your presentation designs and the tools you produce complete protection. For a new technology or process you have created to enhance presentations, you might secure a patent; for the individual slides or design components of a presentation, you might employ copyrights. Trade secrets can be utilized to secure intellectual property that offers a competitive edge; a trademark will help your design company or software to maintain its brand identity.
Layering these kinds of security guarantees that your company’s creative assets as well as its financial ones are safe from several directions. This approach not only safeguards your creative output but also increases the value of your brand, therefore laying a solid basis for expansion and creativity in a cutthroat market.
The Function of a Patenting Law Firm in Preserving Novel Presentation Ideas
Knowing the nuances of intellectual property law can be daunting for a creator or entrepreneur, particularly if your main priorities are operating a company or creating artistic output. Working with a patenting law company can help to make all the difference here. Expert patent lawyers may assist you to determine which facets of your work qualify for protection and walk you through the difficult procedure of obtaining that protection.
Apart from handling the legal aspects, a patenting law company will also offer strategic guidance on how to optimize the value of your intellectual property. Legal professionals make sure your IP portfolio is strong and enforceable whether your goal is to trademark a new software product or defend the brand identification of your company.
Working with IP experts lets you concentrate on your strongest suit—innovation and creation—knowing that your intellectual property is under protection.
Wrapping it up
Within the field of presentation design, your most significant assets are your own ideas and works. Maintaining your competitive edge and making sure your work is not plagiarized or utilized by others depend on securing those assets by intellectual property (IP) rules.
You can develop a multi-layered defense for your company by using copyrights to guard design aspects, patents to guard technological discoveries, trademarks to strengthen your brand, and trade secrets to shield private processes.
Working with a patenting law firm guarantees that you negotiate the legal complexity with simplicity, thereby providing peace of mind and freeing you to concentrate on developing your design company. Protecting your intellectual property is not only a legal need but also a major long-term success and growth strategy in an industry where innovation and creativity rule.
Understanding and implementing these IP methods will help you to boldly defend your original presentation ideas, enhance your brand, and provide new chances for expansion in the very competitive design scene.
Good technical illustrations and data visualisations allow users and clients to, in a manner of speaking, take time out, ponder and look at the information in a really accessible and engaging way. It can obviously also help you communicate certain categories of information and data.
The aim of the article is to inspire and show you how, by using different technical illustrations and data visualisations, you can really engage and communicate with your users and do much more good for the surrounding content.
Below are interesting and not commonly seen examples of technical illustration and data visualisation, that show data and information. As you know, more commonly seen examples are bar graphs and pie charts, but there is so much more than that!
So, keep reading and looking at the following examples, and I will show you some really cool stuff.
Technology
Typically, technical illustration and data visualisations were done using paper, pens, pencils, compasses, and rulers. But now everything is possible — you can do analog and digital. Since the mainstream introduction of the internet, around 1997, data (text, numerical, symbol) has flourished, and it has become the current day gold currency. It is easy for anyone to learn who has the software or knows the coding language. And it is much easier to do technical illustrations and data visualisation than in previous years. But that does not always mean that what is done today is better than what was done before.
What Makes Data And Information Good
It must be aesthetically pleasing, interesting, and stimulating to look at.
It must be of value and worth the effort to read and digest the information.
It must be easy to understand and logical.
To convey ideas effectively, both aesthetic form and functionality need to go hand in hand, as Vitaly Friedman in his article “Data Visualization and Infographics” has pointed out.
It must be legible and have well-named and easy-to-understand axes and labels.
It should help explain and show data and information in a more interesting way than if it were presented in tabular form.
It should help explain or unpack what is written in any surrounding text and make it come to life in an unusual and useful way.
It must be easy to compare and contrast the data against the other data.
The Importance Of Knowing About Different Audiences
There are some common categories of audiences:
Expert,
Intermediate,
Beginner,
Member of the public,
Child,
Teenager,
Middle-aged,
Ageing,
Has some prior knowledge,
Does not have any prior knowledge,
Person with some kind of disability (vision, physical, hearing, mobility).
The audience’s familiarity with the subject matter of your data;
How much context they already have versus what you should provide;
Their familiarity with various methods of data visualisation.
Just look at what we are more often than not presented with.
So, let us dive into some cool examples that you can understand and start using today that will also give your work and content a really cool edge and help it stand out and communicate better.
3D Flow Diagram
It provides a great way to show relationships and connections between items and different components, and the 3D style adds a lot to the diagram.
Card Diagram
It’s an effective way to highlight and select information or data in relation to its surrounding data and information.
Pyramid Graph
Being great at showing two categories of information and comparing them horizontally, they are an alternative to typical horizontal or vertical bar graphs.
3D Examples Of Common Graphs
They are an excellent way to enliven overused 2D pie and bar graphs. 3D examples of common graphs give a real sense of quality and depth whilst enhancing the data and information much more than 2D versions.
Sankey Flow Diagram
This diagram is a good way to show the progression and the journey of information and data and how they are connected in relation to their data value. It’s not often seen, but it’s really cool.
Stream Graph
A stream graph is a great way to show the data and how it relates to the other data — much more interesting than just using lines as is typically seen.
3D Map
It provides an excellent way to show a map in a different and more interesting form than the typically seen 2D version. It really gives the map a sense of environment, depth, and atmosphere.
Tree Map
It’s a great way to show the data spatially and how the data value relates, in terms of size, to the rest of the data.
Waterfall Chart
A waterfall chart is helpful in showing the data and how it relates in a vertical manner to the range of data values.
Doughnut Chart
It shows the data against the other data segments and also as a value within a range of data.
Lollipop Chart
A lollipop chart is an excellent method to demonstrate percentage values in a horizontal manner that also integrates the label and data value well.
Bubble Chart
It’s an effective way to illustrate data values in terms of size and sub-classification in relation to the surrounding data.
How To Start Doing Technical Illustration And Data Visualisation
There are many options available, including specialized software like Flourish, Tableau, and Klipfolio; familiar tools like Microsoft Word, Excel, or PowerPoint (with redrawing in software like Adobe Illustrator, Affinity Designer, or CorelDRAW); or learning coding languages such as D3, Three.js, P5.js, WebGL, or the Web Audio API, as Frederick O’Brien discusses in his article “Web Design Done Well: Delightful Data Visualization Examples.”
But there is one essential ingredient that you will always need, and that is a mind and vision for technical illustration and data visualisation.
I’m a bit uncomfortable that responsive design is often pushed into discreet chunks, like “layout A up to this size, then layout B until there’s enough space for layout C.” It’s OK, it works and fits into a workflow where screens are designed as static layouts in PhotoFigVa (caveat, I made that up). But the process feels like a compromise to me. I’ve long believed that responsive design should be almost invisible to the user. When they visit my site on a mobile device while waiting in line for K-Pop tickets, they shouldn’t notice that it’s different from just an hour ago, sitting at the huge curved gaming monitor they persuaded their boss they needed.
Consider this simple hero banner and its mobile equivalent. Sorry for the unsophisticated design. The image is AI generated, but It’s the only thing about this article that is.
The meerkat and the text are all positioned and sized differently. The traditional way to pull this off is to have two layouts, selected by a media, sorry, container query. There might be some flexibility in each layout, perhaps centering the content, and a little fluid typography on the font-size, but we’re going to choose a point at which we flip the layout in and out of the stacked version. As a result, there are likely to be widths near the breakpoint where the layout looks either a little empty or a little congested.
Is there another way?
It turns out there is. We can apply the concept of fluid typography to almost anything. This way we can have a layout that fluidly changes with the size of its parent container. Few users will ever see the transition, but they will all appreciate the results. Honestly, they will.
Let’s get this styled up
For the first step, let’s style the layouts individually, a little like we would when using width queries and a breakpoint. In fact, let’s use a container query and a breakpoint together so that we can easily see what properties need to change.
This is the markup for our hero, and it won’t change:
I’ve attached the background image to a ::before pseudo-element so I can use container queries on it (because containers cannot query themselves). We’ll keep this later on so that we can use inline container query (cqi) units. For now, here’s the container query that just shows the values we’re going to make fluid:
You can see the code running in a live demo — it’s entirely static to show the limitations of a typical approach.
Let’s get fluid
Now we can take those start and end points for the size and position of both the text and background and make them fluid. The text size uses fluid typography in a way you are already familiar with. Here’s the result — I’ll explain the expressions once you’ve looked at the code.
First the changes to the position and size of the text:
/* Line changes
* -12,27 +12,32
*/
.details {
/* ... lines 14-16 unchanged */
/* Evaluates to 50px for a 360px wide container, and 220px for 1200px */
top: clamp(50px, 20.238cqi - 22.857px, 220px);
/* Evaluates to 20px for a 360px wide container, and 565px for 1200px */
left: clamp(20px, 64.881cqi - 213.571px, 565px);
/* ... lines 20-25 unchanged */
h1 {
/* Evaluates to 3.5rem for a 360px wide container, and 5rem for 1200px */
font-size: clamp(3.5rem, 2.857rem + 2.857cqi, 5rem);
/* ... font-weight unchanged */
}
p {
/* Evaluates to 2rem for a 360px wide container, and 2.5rem for 1200px */
font-size: clamp(2rem, 1.786rem + 0.952cqi, 2.5rem);
}
}
And here’s the background position and size for the meerkat image:
/* Line changes
* -50,3 +55,8
*/
/* Evaluates to -310px for a 360px wide container, and 0px for 1200px */
background-position-x: clamp(-310px, 36.905cqi - 442.857px, 0px);
/* Evaluates to -25px for a 360px wide container, and 0px for 1200px */
background-position-y: clamp(-25px, 2.976cqi);
/* Evaluates to 710px for a 360px wide container, and 589px for 1200px */
background-size: auto clamp(589px, 761.857px - 14.405cqi, 710px);
Now we can drop the container query entirely.
Let’s explain those clamp() expressions. We’ll start with the expression for the top property.
/* Evaluates to 50px for a 360px wide container, and 220px for 1200px */
top: clamp(50px, 20.238cqi - 22.857px, 220px);
You’ll have noticed there’s a comment there. These expressions are a good example of how magic numbers are a bad thing. But we can’t avoid them here, as they are the result of solving some simultaneous equations — which CSS cannot do!
The upper and lower bounds passed to clamp() are clear enough, but the expression in the middle comes from these simultaneous equations:
f + 12v = 220
f + 3.6v = 50
…where f is the number of fixed-size length units (i.e., px) and v is the variable-sized unit (cqi). In the first equation, we are saying that we want the expression to evaluate to 220px when 1cqi is equal to 12px. In the second equation, we’re saying we want 50px when 1cqi is 3.6px, which solves to:
f = -22.857
v = 20.238
…and this tidies up to 20.238cqi – 22.857px in a calc()-friendly expression.
When the fixed unit is different, we must change the size of the variable units accordingly. So for the
element’s font-size we have;
/* Evaluates to 2rem for a 360px wide container, and 2.5rem for 1200px */
font-size: clamp(2rem, 1.786rem + 0.952cqi, 2.5rem);
This is solving these equations because, at a container width of 1200px, 1cqi is the same as 0.75rem (my rems are relative to the default UA stylesheet, 16px), and at 360px wide, 1cqi is 0.225rem.
f + 0.75v = 2.5
f + 0.225v = 2
This is important to note: The equations are different depending on what unit you are targeting.
Honestly, this is boring math to do every time, so I made a calculator you can use. Not only does it solve the equations for you (to three decimal places to keep your CSS clean) it also provides that helpful comment to use alongside the expression so that you can see where they came from and avoid magic numbers. Feel free to use it. Yes, there are many similar calculators out there, but they concentrate on typography, and so (rightly) fixate on rem units. You could probably port the JavaScript if you’re using a CSS preprocessor.
The clamp() function isn’t strictly necessary at this point. In each case, the bounds of clamp() are set to the values of when the container is either 360px or 1200px wide. Since the container itself is constrained to those limits — by setting min-width and max-width values — the clamp() expression should never invoke either bound. However, I prefer to keep clamp() there in case we ever change our minds (which we are about to do) because implicit bounds like these are difficult to spot and maintain.
Avoiding injury
We could consider our work finished, but we aren’t. The layout still doesn’t quite work. The text passes right over the top of the meerkat’s head. While I have been assured this causes the meerkat no harm, I don’t like the look of it. So, let’s make some changes to make the text avoid hitting the meerkat.
The first is simple. We’ll move the meerkat to the left more quickly so that it gets out of the way. This is done most easily by changing the lower end of the interpolation to a wider container. We’ll set it so that the meerkat is fully left by 450px rather than down to 360px. There’s no reason the start and end points for all of our fluid expressions need to align with the same widths, so we can keep the other expressions fluid down to 360px.
Using my trusty calculator, all we need to do is change the clamp() expressions for the background-position properties:
/* Line changes
* -55,5 +55,5
*/
/* Evaluates to -310px for a 450px wide container, and 0px for 1200px */
background-position-x: clamp(-310px, 41.333cqi - 496px, 0px);
/* Evaluates to -25px for a 450px wide container, and 0px for 1200px */
background-position-y: clamp(-25px, 3.333cqi - 40px, 0px);
This improves things, but not totally. I don’t want to move it any quicker, so next we’ll look at the path the text takes. At the moment it moves in a straight line, like this:
But can we bend it? Yes, we can.
A Bend in the path
One way we can do this is by defining two different interpolations for the top coordinate that places the line at different angles and then choosing the smallest one. This way, it allows the steeper line to “win” at larger container widths, and the shallower line becomes the value that wins when the container is narrower than about 780px. The result is a line with a bend that misses the meerkat.
All we’re changing is the top value, but we must calculate two intermediate values first:
/* Line changes
* -18,2 +18,9 @@
*/
/* Evaluates to 220px for a 1200px wide container, and -50px for 360px */
--top-a: calc(32.143cqi - 165.714px);
/* Evaluates to 120px for a 1200px wide container, and 50px for 360px */
--top-b: calc(20px + 8.333cqi);
/* By taking the max, --topA is used at lower widths, with --topB taking over when wider.
We only need to apply clamp when the value is actually used */
top: clamp(50px, max(var(--top-a), var(--top-b)), 220px);
For these values, rather than calculating them formally using a carefully chosen midpoint, I experimented with the endpoints until I got the result I wanted. Experimentation is just as valid as calculation as a way of getting the result you need. In this case, I started with duplicates of the interpolation in custom variables. I could have split the path into explicit sections using a container query, but that doesn’t reduce the math overhead, and using the min() function is cleaner to my eye. Besides, this article isn’t strictly about container queries, is it?
Now the text moves along this path. Open up the live demo to see it in action.
CSS can’t do everything
As a final note on the calculations, it’s worth pointing out that there are restrictions as far as what we can and can’t do. The first, which we have already mitigated a little, is that these interpolations are linear. This means that easing in or out, or other complex behavior, is not possible.
Another major restriction is that CSS can only generate length values this way, so there is no way in pure CSS to apply, for example, opacity or a rotation angle that is fluid based on the container or viewport size. Preprocessors can’t help us here either because the limitation is on the way calc() works in the browser.
Both of these restrictions can be lifted if you’re prepared to rely on a little JavaScript. A few lines to observe the width of the container and set a CSS custom property that is unitless is all that’s needed. I’m going to use that to make the text follow a quadratic Bezier curve, like this:
There’s too much code to list here, and too much math to explain the Bezier curve, but go take a look at it in action in this live demo.
We wouldn’t even need JavaScript if expressions like calc(1vw / 1px) didn’t fail in CSS. There is no reason for them to fail since they represent a ratio between two lengths. Just as there are 2.54cm in 1in, there are 8px in 1vw when the viewport is 800px wide, so calc(1vw / 1px) should evaluate to a unitless 8 value.
They do fail though, so all we can do is state our case and move on.
Fluid everything doesn’t solve all layouts
There will always be some layouts that need size queries, of course; some designs will simply need to snap changes at fixed breakpoints. There is no reason to avoid that if it’s right. There is also no reason to avoid mixing the two, for example, by fluidly sizing and positioning the background while using a query to snap between grid definitions for the text placement. My meerkat example is deliberately contrived to be simple for the sake of demonstration.
One thing I’ll add is that I’m rather excited by the possibility of using the new Anchor Positioning API for fluid positioning. There’s the possibility of using anchor positioning to define how two elements might flow around the screen together, but that’s for another time.
We’ve all had that moment. You’re optimizing the performance of some website, scrutinizing every millisecond it takes for the current page to load. You’ve fired up Google Lighthouse from Chrome’s DevTools because everyone and their uncle uses it to evaluate performance.
After running your 151st report and completing all of the recommended improvements, you experience nirvana: a perfect 100% performance score!
Time to pat yourself on the back for a job well done. Maybe you can use this to get that pay raise you’ve been wanting! Except, don’t — at least not using Google Lighthouse as your sole proof. I know a perfect score produces all kinds of good feelings. That’s what we’re aiming for, after all!
Google Lighthouse is merely one tool in a complete performance toolkit. What it’s not is a complete picture of how your website performs in the real world. Sure, we can glean plenty of insights about a site’s performance and even spot issues that ought to be addressed to speed things up. But again, it’s an incomplete picture.
What Google Lighthouse Is Great At
I hear other developers boasting about perfect Lighthouse scores and see the screenshots published all over socials. Hey, I just did that myself in the introduction of this article!
Lighthouse might be the most widely used web performance reporting tool. I’d wager its ubiquity is due to convenience more than the quality of its reports.
Open DevTools, click the Lighthouse tab, and generate the report! There are even many ways we can configure Lighthouse to measure performance in simulated situations, such as slow internet connection speeds or creating separate reports for mobile and desktop. It’s a very powerful tool for something that comes baked into a free browser. It’s also baked right into Google’s PageSpeed Insights tool!
And it’s fast. Run a report in Lighthouse, and you’ll get something back in about 10-15 seconds. Try running reports with other tools, and you’ll find yourself refilling your coffee, hitting the bathroom, and maybe checking your email (in varying order) while waiting for the results. There’s a good reason for that, but all I want to call out is that Google Lighthouse is lightning fast as far as performance reporting goes.
To recap: Lighthouse is great at many things!
It’s convenient to access,
It provides a good deal of configuration for different levels of troubleshooting,
And it spits out reports in record time.
And what about that bright and lovely animated green score — who doesn’t love that?!
OK, that’s the rosy side of Lighthouse reports. It’s only fair to highlight its limitations as well. This isn’t to dissuade you or anyone else from using Lighthouse, but more of a heads-up that your score may not perfectly reflect reality — or even match the scores you’d get in other tools, including Google’s own PageSpeed Insights.
It Doesn’t Match “Real” Users
Not all data is created equal in capital Web Performance. It’s important to know this because data represents assumptions that reporting tools make when evaluating performance metrics.
The data Lighthouse relies on for its reporting is called simulated data. You might already have a solid guess at what that means: it’s synthetic data. Now, before kicking simulated data in the knees for not being “real” data, know that it’s the reason Lighthouse is super fast.
You know how there’s a setting to “throttle” the internet connection speed? That simulates different conditions that either slow down or speed up the connection speed, something that you configure directly in Lighthouse. By default, Lighthouse collects data on a fast connection, but we can configure it to something slower to gain insights on slow page loads. But beware! Lighthouse then estimates how quickly the page would have loaded on a different connection.
“[Simulated throttling] reduces variability between tests. But if there’s a single slow render-blocking request that shares an origin with several fast responses, then Lighthouse will underestimate page load time.
Lighthouse averages optimistic and pessimistic estimates when it’s unsure exactly which nodes block rendering. In practice, metrics may be closer to either one of these, depending on which dependency graph is more correct.”
And again, the environment is a configuration, not reality. It’s unlikely that your throttled conditions match the connection speeds of an average real user on the website, as they may have a faster network connection or run on a slower CPU. What Lighthouse provides is more like “on-demand” testing that’s immediately available.
That makes simulated data great for running tests quickly and under certain artificially sweetened conditions. However, it sacrifices accuracy by making assumptions about the connection speeds of site visitors and averages things in a way that divorces it from reality.
While simulated throttling is the default in Lighthouse, it also supports more realistic throttling methods. Running those tests will take more time but give you more accurate data. The easiest way to run Lighthouse with more realistic settings is using an online tool like the DebugBear website speed test or WebPageTest.
It Doesn’t Impact Core Web Vitals Scores
These Core Web Vitals everyone talks about are Google’s standard metrics for measuring performance. They go beyond simple “Your page loaded in X seconds” reports by looking at a slew of more pertinent details that are diagnostic of how the page loads, resources that might be blocking other resources, slow user interactions, and how much the page shifts around from loading resources and content. Zeunert has another great post here on Smashing Magazine that discusses each metric in detail.
The main point here is that the simulated data Lighthouse produces may (and often does) differ from performance metrics from other tools. I spent a good deal explaining this in another article. The gist of it is that Lighthouse scores do not impact Core Web Vitals data. The reason for that is Core Web Vitals relies on data about real users pulled from the monthly-updated Chrome User Experience (CrUX) report. While CrUX data may be limited by how recently the data was pulled, it is a more accurate reflection of user behaviors and browsing conditions than the simulated data in Lighthouse.
The ultimate point I’m getting at is that Lighthouse is simply ineffective at measuring Core Web Vitals performance metrics. Here’s how I explain it in my bespoke article:
“[Synthetic] data is fundamentally limited by the fact that it only looks at a single experience in a pre-defined environment. This environment often doesn’t even match the average real user on the website, who may have a faster network connection or a slower CPU.”
I emphasized the important part. In real life, users are likely to have more than one experience on a particular page. It’s not as though you navigate to a site, let it load, sit there, and then close the page; you’re more likely to do something on that page. And for a Core Web Vital metric that looks for slow paint in response to user input — namely, Interaction to Next Paint (INP) — there’s no way for Lighthouse to measure that at all!
It’s the same deal for a metric like Cumulative Layout Shift (CLS) that measures the“visible stability” of a page layout because layout shifts often happen lower on the page after a user has scrolled down. If Lighthouse relied on CrUX data (which it doesn’t), then it would be able to make assumptions based on real users who interact with the page and can experience CLS. Instead, Lighthouse waits patiently for the full page load and never interacts with parts of the page, thus having no way of knowing anything about CLS.
But It’s Still a “Good Start”
That’s what I want you to walk away with at the end of the day. A Lighthouse report is incredibly good at producing reports quickly, thanks to the simulated data it uses. In that sense, I’d say that Lighthouse is a handy “gut check” and maybe even a first step to identifying opportunities to optimize performance.
But a complete picture, it’s not. For that, what we’d want is a tool that leans on real user data. Tools that integrate CrUX data are pretty good there. But again, that data is pulled every month (28 days to be exact) so it may not reflect the most recent user behaviors and interactions, although it is updated daily on a rolling basis and it is indeed possible to query historical records for larger sample sizes.
Even better is using a tool that monitors users in real-time.
Data pulled directly from the site of origin is truly the gold standard data we want because it comes from the source of truth. That makes tools that integrate with your site the best way to gain insights and diagnose issues because they tell you exactly how your visitors are experiencing your site.
I’ve written about using the Performance API in JavaScript to evaluate custom and Core Web Vitals metrics, so it’s possible to roll that on your own. But there are plenty of existing services out there that do this for you, complete with visualizations, historical records, and true real-time user monitoring (often abbreviated as RUM). What services? Well, DebugBear is a great place to start. I cited Matt Zeunert earlier, and DebugBear is his product.
So, if what you want is a complete picture of your site’s performance, go ahead and start with Lighthouse. But don’t stop there because you’re only seeing part of the picture. You’ll want to augment your findings and diagnose performance with real-user monitoring for the most complete, accurate picture.
As an entrepreneur, you have to be willing to self-promote and build your own personal brand (alongside that of your business brands, of course). And while there are hundreds of ways to do this, blogging is still one of the best.
The Perks of Building Your Own Blog
As an entrepreneur, you have lots of different avenues available to you for building your brand and establishing connections. However, blogging remains one of the best options. Here a few of the top reasons why:
1. Strengthens Your Online Presence
Having a strong online presence is important. And blogging is one of the best ways to increase your visibility and ensure that potential clients, partners, and investors can easily find you. Your blog will allow you to create multiple entry points for people to discover your personal brand and business.
A blog acts as a hub for all your thoughts, ideas, and expertise. It gives people a central place to learn about you and your business, beyond what’s on your social media profiles or website landing pages. Each blog post you publish is another opportunity to attract visitors to your site, showcase your knowledge, and demonstrate your value.
Plus, a blog allows you to maintain control over your narrative. Unlike social media, where algorithms can change and limit your reach, your blog is your space. You decide the content, the message, and how you engage with your audience.
2. Establishes Authority
Regularly blogging about topics related to your industry is one of the best ways to establish yourself as an expert in your field.
When you share your knowledge through well-researched, insightful blog posts, you’re not just helping your readers – you’re building credibility. Over time, your audience will start to see you as a go-to resource for industry-related information. This authority can translate into more business opportunities, as people are more likely to trust and engage with someone who demonstrates expertise.
Being seen as an authority in your field also opens doors to speaking engagements, guest appearances on other platforms, and collaborations with other experts in your industry. It can even help you gain media attention, as journalists often look for authoritative sources to quote in articles.
3. Drives Organic Search Traffic
One of the biggest benefits of blogging for entrepreneurs is the opportunity to attract organic search traffic. Every blog post you write is an opportunity to optimize for search engines, helping you rank higher on Google and other search platforms. This is especially important if you’re just starting out and don’t have a huge marketing budget.
By focusing on SEO-rich content – content that’s optimized with relevant keywords, meta descriptions, and internal/external links – you can naturally bring in readers who are searching for information related to your business or industry. For example, if you’re a fitness entrepreneur, a blog post about “how to stay fit while working from home” could attract people searching for fitness tips, who might then learn more about your products or services.
As you publish more content and your blog starts gaining traction in search results, you’ll notice an increase in organic traffic, which means more eyes on your brand and business without spending extra money on ads.
4. Builds and Fosters a Community
Blogging gives you a unique opportunity to directly engage with your audience and foster a sense of community around your brand. When you write blog posts that resonate with your readers, they’re more likely to interact with your content – whether by leaving comments, sharing your posts on social media, or subscribing to your newsletter.
This type of engagement allows you to build a loyal following of people who not only support your business but also feel connected to you personally. The more you interact with your readers, the stronger that connection becomes. Blogging also opens up the opportunity for valuable feedback. Your readers might leave comments that inspire new blog topics, help you improve your products or services, or give you insights into what your audience is most interested in.
5. Natural Promotion for Your Products
One of the most effective ways to promote your products and services without being too salesy is through blogging. Rather than directly pitching your offerings, you can write informative, helpful content that naturally ties back to what you sell.
For example, if you run an online store that sells eco-friendly products, you could write blog posts about the importance of sustainability, offer tips for reducing waste, and highlight the benefits of using green products. Throughout the post, you can subtly mention your products and link to them as part of the solution.
This approach positions you as someone who cares about educating your audience, rather than just pushing a sale. And when readers see the value in what you offer, they’re more likely to trust your recommendations and make a purchase.
6. Keeps You Relevant and Adaptable
Blogging keeps you relevant in your industry. It gives you a platform to share your thoughts on the latest trends, discuss emerging technologies, and offer insights on current events that affect your niche. By staying active in the conversation, you show that you’re not only knowledgeable but also adaptable.
As your industry evolves, your blog can evolve, too. It’s a flexible tool that can grow with your business and help you stay ahead of the curve. Whether you’re launching a new product, expanding into a new market, or simply shifting focus, your blog can reflect those changes and keep your audience informed.
Putting it All Together
There’s no one-size-fits-all solution to building your brand as an entrepreneur. However, certain strategies pack more punch than others. Blogging is one of them. By starting a blog, you can enjoy many of the benefits highlighted in this article and give yourself a better chance to be successful in the months and years to come!
If you have a profitable side hustle, you’ve probably considered taking your business full-time. However, before you take the leap and transition to life as a full-time entrepreneur, there are a few things you should do.
Some tasks are simple, like opening a business bank account and setting concrete goals. Others, like building a professional website, investing in growth strategies, and networking, will take more time and consideration.
There’s no doubt the process can be overwhelming, so here are eight specific things you can do to prepare for the transition.
Register Your Business and Open a Bank Account
If you haven’t yet, make sure to register your business. An accountant or business attorney can advise you on the best business formation, such as an LLC. Once you’ve registered your business officially, open a dedicated business bank account.
Many solopreneurs start their businesses without these initial steps. However, if you want to transition to full-time self-employment, it’s essential to treat your business like the professional entity that it is.
Set Concrete Goals
Successful entrepreneurs create clearly defined, easy-to-track business goals. So, before you quit your job and take your business full-time, write down specific benchmarks you want to achieve. Whether it’s a certain number of customers or a revenue goal, sketch out where you’d like to be at the three-month, six-month, and twelve-month mark of being a full-time entrepreneur.
Create a business plan that outlines how you will market your business, how you plan to grow it, and why you expect to stand out in the market. Researching your competitors and seeing what they’re doing right (and wrong) is also important.
Take this information and use your research to help you make a comprehensive plan to follow. That way, you know what to do on your first day of self-employment and beyond.
Secure Funding
Some businesses, particularly online ones, don’t have significant start-up costs. However, others, such as brick-and-mortar businesses or technology start-ups, will require upfront cash.
There are many different ways you can fund your business start-up costs. You can self-fund it from personal savings, get a personal loan, or apply for a business line of credit.
The funding route you choose will depend on your business goals, the type of business you have, and whether or not you want to give up equity in exchange for funding. For example, many entrepreneurs choose to pitch venture capital firms but give up equity in the process. Others apply for SBA loans, like the SBA 504 loan.
Create a Website and Social Media Presence
Your website and social media profiles are some of the first things your customers or clients will see. Make sure you have a professional website and that your social media accounts reflect your business values.
Your business website should explain what you do clearly and have an easy way to contact you, while your social accounts should have a consistent brand presence with similar color schemes and your logo.
Update your social media accounts regularly and take the time to learn about social media and email marketing as ways to grow your client and customer base.
Build a Strong Client or Customer List
Speaking of clients and customers, it’s vital to have plans to reach them before you make the leap to self-employment. If you have clients that use your services, build a list of several that can provide recurring revenue so you can project your first few months of self-employment income.
If you serve customers, take the time to understand the best ways to acquire new ones. Test multiple marketing strategies and methods until you find a consistent way to keep customers coming back to your business regularly.
Once you build a strong and consistent client or customer base and you know you can reliably earn income while you’re self-employed, you can begin to make concrete plans to transition into full-time entrepreneurship.
Set Up Health Insurance and Benefits
While some may enjoy the benefits of insurance coverage from a spouse, many others will need to find their own plan after leaving their day job. For those who’ve never done this before, this can require a bit of research.
When you work for yourself, you’ll also need to arrange any “benefits,” like retirement plans. It’s a good idea to explore these costs ahead of time to ensure that your business income can cover the cost of your taxes, payroll, and more.
Invest in Growth Strategies
As you’re preparing to take your business full-time, invest in growth strategies. For example, make sure you’re regularly learning new skills and researching business grants. If you know you’ll need to purchase real estate as part of your business plan, find ways that you can buy property affordably or qualify for home buyer rebates.
Learn how to manage your bookkeeping and spend time understanding your cash flow. This information will help you know whether or not you can hire additional team members or invest in other products or services in the future as you grow.
Network and Find Mentors
Mentors who have made the leap from side hustle to full-time job can help you determine whether or not you’re ready to do the same. When you network and learn from others, it can help you avoid mistakes, saving you valuable time and money.
Networking in person is ideal, but it’s also wise to build your connections on LinkedIn to connect with entrepreneurs in similar industries. Connecting online means you’re not limited to business owners in your area, dramatically expanding your reach.
Take the Leap
Once you’ve completed the steps above, you’re likely ready to take the leap, even if you don’t feel completely ready. Many people are worried about their livelihoods, rising costs, and the economy overall, but data from a 2024 economic outlook shows economists don’t believe a recession is imminent. That means it might be a perfect time to break out on your own.
Keep these steps in mind before going full-time, and you’ll put yourself on the path to business success.
