Entries by admin

State Of GDPR In 2021: Key Updates And What They Mean

/0 Comments/in /by

Original Source: https://smashingmagazine.com/2021/02/state-gdpr-2021-key-updates/

The EU’s directives have impacted virtually every digital professional as products and services are designed with GDPR in mind, regardless of whether you’re a web design company in Wisconsin or a marketer in Malta. The far-reaching implications of GDPR don’t just impact how data should be processed, how products should be built and how data is transferred securely within and between organisations. It defines international data transfer agreements like that between Europe and America.

Kevin Kelly, one of the world’s brightest digital futurists, claims that ‘Technology is as great a force as nature’. What he means by that is that user data and information technology is causing one of the most profound periods in human history since the invention of language. Just look at what is happening as governments and the tech multinationals grapple to control the Internet.

Last week alone, as the Australian government moved to force platform owners to pay publishers for the content that’s shared on their platform, Facebook decided to block news to Australian users with a huge uproar from the Australian government.

And that’s in addition to previous controversies (the organisation of the U.S. Capitol riot, the Cambridge Analytica scandal) at the intersection where government and technology meet.

In this article, we’ll look at how GDPR has evolved since 2018. We’ll run through some updates from the EU, some key developments, and where GDPR is likely to evolve. We’ll explore what that means for us, as designers and developers. And we’ll look at what that means for companies both inside and outside the EU.

In the next article, we’ll focus on cookie consent and the paradox where marketers are heavily reliant on Google Analytics cookie data but need to comply with regulations. And then we’ll take a deep dive into first-party ad tracking as we start to see moves away from third-party cookies.

Part 1: GDPR, Key Updates And What They Mean
Part 2: GDPR, Cookie Consent and 3rd Parties (next week)
Subcribe to our newsletter to not miss it.

A Quick Recap Of GDPR

Let’s start by reminding ourselves what GDPR is. The GDPR became law within the EU on 25 May 2018. It’s based on 7 key principles:

Lawfulness, fairness and transparency
You must process data so that people understand what, how, and why you’re processing their data.
Purpose limitation
You should only collect data for clear, specified, and legitimate purposes. You can’t then process it in ways that are incompatible with your original purposes.
Data minimization
You should only collect the data you need.
Accuracy
Your data must be accurate and kept up to date. Inaccurate data should be erased or corrected.
Storage limitation
If data can be linked to individuals, you can only keep it for as long as you need to carry out the purposes you specified. (Caveats for scientific, statistical, or historical research use.)
Integrity and confidentiality (i.e. security)
You must ensure the personal data you hold is processed securely. You must protect it from unauthorized or unlawful processing and against accidental loss, destruction, or damage.
Accountability
You are now responsible for the data you hold and should be able to demonstrate your compliance with the GDPR.

Some Definitions

CJEU
Court of Justice of the European Union. This court’s decisions clarify EU laws like GDPR.
DPAs
National Data Protection Authorities. Each EU country has one. GDPR is enforced, and fines are issued, at the national level by these bodies. The UK equivalent is the Information Commissioner’s Office (ICO). In the United States, GDPR-style data privacy is largely legislated by each state.
European Commission
The executive branch of the European Union (essentially the EU’s civil service). The European Commission drafts legislation including the GDPR.
GDPR
The 2018 General Data Protection Regulation.

Key Updates From The EU

GDPR hasn’t stood still since May 2018. Here’s a quick run-through of what’s happened since it came into effect.

How Have The EU And Its Member States Implemented GDPR?

The European Commission reports that GDPR is almost fully implemented across the EU, though some countries — it namechecks Slovenia — have dragged their feet. However, the depth of implementation varies. The EU also says its member countries are, in its opinion, using their new powers fairly.

However, it has also expressed concern that some divergence and fragmentation are creeping in. GDPR can only work effectively across the EU’s single market if member states are aligned. If the laws diverge, it muddies the water.

How Does The EU Want GDPR To Develop?

We know the EU wants it to be easier for individuals to exercise their rights under GDPR. That means cross-border collaboration and class-action lawsuits. It wants to see data portability for consumers beyond banking and telecoms.

It also wants to make it easier for
small and medium-sized enterprises (SMEs) to comply with GDPR. That’s likely to come in the form of extra support and tools such as more standard contractual clauses — essentially templated legalese that SMEs can copy/paste into contracts — as the EU isn’t keen to bend the rules for them.

Big Development #1: The Unexpectedly Broad Definition Of ‘Joint Controller’

Right, here’s the first big change since GDPR became law. In two test cases involving Facebook, the Court of Justice of the European Union has defined a far broader interpretation of ‘joint controller’ than expected.

A joint controller situation arises when two or more controllers both have responsibility for meeting the terms of the GDPR. (Here’s a good explainer from the ICO on joint controllers.) Essentially:

When you process customer data, you decide with your fellow joint controller(s) who will manage each step so you’re compliant with the GDPR.
However, you all have full responsibility to ensure the entire process is compliant. Each of you is fully accountable to the data protection authority in the country handling any complaints.
An individual can raise a complaint against each and all joint controllers.
You are all responsible for any damage caused — unless you can prove you have no connection to the event that’s caused the damage.
An individual can seek compensation from any joint controller. You may be able to reclaim some of that compensation from your fellow controllers.

In the first Facebook case, the CJEU confirmed that a company that ran a Facebook fan page counted as a joint controller alongside Facebook. In the second, the CJEU also confirmed that a company that embedded a Facebook Like button onto its website held joint controller status with the social network.

These cases sent shockwaves through the privacy community, as essentially it makes social publishers, website operators, and fan page moderators responsible for user data alongside platforms like Facebook.

However, the CJEU also clarified that shared responsibility does not mean equal responsibility. In both cases, responsibility sat primarily with Facebook — only Facebook had access to the data and only Facebook could delete it. So the impact of this decision may be less severe than it sounds at first — but it’s still critically important.

And that might be why some sites — such as the website for Germany’s 2020 presidency of the EU — block embedded social content by default, until you’ve specifically opted in:

Big Development #2: Bye Bye Privacy Shield, Hello CPRA

The second big change was more predictable: Privacy Shield, the mechanism that made it easier for American businesses to process European customer data, has been struck down by the courts.

Here’s why.

The EU wants to protect its citizens’ personal data. However, it also wants to encourage international trade, plus cross-border collaboration in areas like security.

The EU sees itself — quite rightly — as a pioneer in data protection. So it’s using its political muscle to encourage countries who want to trade with the bloc to match its data privacy standards.

Enter the United States. European and American philosophies around data privacy are diametrically opposed. (In essence, the European view is that personal data is private unless you give explicit permission. The American view is that your data is public unless you expressly request that it’s kept private.) But as the world’s two biggest consumer markets, they need to trade. So the EU and the US developed Privacy Shield.

Privacy Shield was designed to enable US companies to process EU citizens’ data, as long as those companies signed up to its higher privacy standards.

But under US law, the US government could still monitor that data. This was challenged in a case brought by Austrian privacy advocate Max Schrems. The CJEU sided with him: Privacy Shield was struck down and the 5,300 American SMEs who used Privacy Shield were given no choice but to adopt the EU’s prescribed Standard Contractual Clauses.

Obviously, it’s in everyone’s interests for Privacy Shield to be replaced — and it will be. But experts say that its replacement is likely to be struck down again in due course because European and American approaches to privacy are essentially incompatible.

Meanwhile, in California, 2018’s GDPR-inspired California Consumer Privacy Act (CCPA) was strengthened in November 2020 when the California Privacy Rights Act (CPRA) was passed.

The California Consumer Privacy Act (CCPA)

The CCPA, which came into effect in January 2020, gives California citizens the right to opt out of their data being sold. They can also ask for any data that’s been collected to be disclosed and they can ask for that data to be deleted.
Unlike GDPR, the CCPA only applies to commercial companies:

Who process the data of more than 50,000 California residents a year, OR
Who generate gross revenue of more than $25m a year, OR
Who make more than half of their annual revenue from selling California residents’ personal data

The California Privacy Rights Act (CPRA)

The CPRA, which comes into force in January 2023, goes beyond the CCPA. Its key points include:

It raises the bar to companies that process the data of 100,000 California residents a year
It gives more protection to Californians’ sensitive data, such as their race, religion, sexual orientation, and health data and government ID
It triples the fines for breaches of minors’ data
It gives Californians the right to request their data is corrected
It obliges companies to help with CPRA investigations
And it establishes a California Privacy Protection Agency to enforce the CPRA

Further pushes towards privacy laws are happening in other states, and together these may reinforce the need for federal privacy measures under the new Biden administration.

Big Development #3: Cookie Consent

In May 2020, the EU updated its GDPR guidance to clarify several points, including two key points for cookie consent:

Cookie walls do not offer users a genuine choice, because if you reject cookies you’re blocked from accessing content. It confirms that cookie walls should not be used.
Scrolling or swiping through web content does not equate to implied consent. The EU reiterates that consent must be explicit.

I’ll be going deeper into this in the second article next week.

Big Development #4: Google And Apple Start To Shift From Third-Party Tracking

As the big digital players figure out how to meet GDPR — and how to turn privacy legislation to their advantage — some have already come under fire.

Both Google and Apple are facing antitrust lawsuits, following complaints from adtech companies and publishers.

In both cases, the complainants says the big tech companies are exploiting their dominant market position.

Again, more on this next time.

Big Development #5: Big GDPR Fines Coming This Way

Of course, many organizations jumped to comply with GDPR because they feared the fines that regulators could apply. Those fines have started rolling in:

The French data regulator has slapped Google with a €50m fine for “lack of transparency, inadequate information and lack of valid consent regarding ads personalization”, saying users were “not sufficiently informed” about how and why Google collected their data.

Its UK equivalent, the ICO, has fined US hotel conglomerate Marriott International Inc. £18.4m for failing to keep 339 million guest records secure. The 2014 cyber-attack on Starwood Hotels and Resorts Worldwide, Inc., which Marriott acquired in 2016, wasn’t discovered until 2018.

The UK’s ICO has also fined British Airways a record £20m for a 2018 data breach of 400,000 customers’ personal and credit card data.

Then there’s my personal favorite, a shocking breach of employee trust by H&M that led to a €35m penalty.

So that’s where we stand today.

What Does This Mean For You?

As designers and developers, GDPR has — and will continue to have — a big impact in the products we design and build, and the way that we design for data.

Here’s What We, As Designers, Should Know

GDPR is critical for you because you’ll design the points at which users share their data, what data is collected, and how it’s processed.
Follow Privacy by Design best practices. Don’t try to reinvent the wheel — if you’ve created a compliant cookie banner, use your proven design pattern.
Work with your compliance and development teams to ensure designs meet GDPR and can be implemented. Only ask for the data you need.
Finally, ask your users what data they’re comfortable sharing and how they’d like you to use it. If they find it creepy, revisit your approach.

Here’s What We, As Developers, Should Know

GDPR is critical for you because you enable data processing, sharing and integrations.
As a general rule with GDPR, take a need-to-access approach. Start by implementing everything with no access, then only give your team access to data as and when it’s necessary (e.g. giving developers access to the Google Analytics console). Audit and document as you go.
Follow privacy by design and security by design principles. Robust, secure templates for implementing infrastructure are key.
Make sure you’re involved upfront about technical aspects e.g. cookie consent/tracking conversations, so what’s decided can be implemented.
Process mapping shows where data is being shared with different parts of the business.
Automation offers secure data handling that cuts human error. It also helps prevent the wrong people accessing data.
GDPR checklists and of course run books will help you manage your process. Again, audit and document as you go.

Now let’s see how GDPR is going to evolve in the near future. We’ll focus on three areas.

Three Areas Where GDPR Is Swiftly Evolving
1. How The EU Is Implementing GDPR

First up, let’s see how GDPR will be further embedded in the legislative landscape.

The EU wants to keep its member states aligned, because that will make cross-border suits and international collaboration easier. So it has reinforced that countries should neither divert from, nor overstep the GDPR. Some member states, as I said, are paying lip service to the regulation. Others want to exceed GDPR’s standards.

In return for their alignment, the EU will enforce compliance, work to enable class action and cheaper cross-border suits, and also promote privacy and consistent standards outside the EU. In addition to extra support and tools for SMEs, we may also see certification for security and data protection by design.

Finally, this could raise some eyebrows in Silicon Valley: the EU has hinted that it might consider bans on data processing to encourage compliance. €50m fines aren’t the end of the world for Google and friends. But time out on the naughty step — and the resulting bad PR — is a very different thing.

2. How GDPR Works With Innovation

GDPR was designed to be technology-neutral and to support, not hinder, innovation. That’s certainly been tested over the past 12 months, and the EU points to the rapid rollout of COVID-19 apps as proof that its legislation works.

We can expect to see codes of conduct for sensitive categories of data (health and scientific research). These will be welcomed.

However, they’re watching innovators closely. The EU has expressed concern about data privacy in video, IoT devices and blockchain. They are particularly concerned about facial (and presumably voice) recognition and developments in AI.

Most notably, the Commission is deeply concerned about what it calls “multinational technology companies”, “large digital platforms” and “online advertising and micro-targeting”. Yes, once again it’s looking at you, Facebook, Amazon, Google and friends.

3. How The EU Is Promoting GDPR Standards Beyond The EU

Our digital economy is global, so GDPR’s impact ripples beyond the EU’s borders — and not just in terms of compliance. The EU is setting the bar for data protection legislation worldwide. Beyond California’s CCPA, see Brazil’s LGPD, plus developments in Canada, Australia, India and a clutch of American states.

Of course, it’s in the EU’s interests if other countries and trading blocs match their standards. So it’s promoting GDPR via several avenues:

Through “mutual adequacy decisions” with Japan and shortly South Korea
Embedded into bilateral trade agreements e.g. with New Zealand, Australia, UK
Through fora like the OECD, ASEAN, the G7 and the G20
Through its Data Protection Academy for EU and international regulators

It is particularly keen to empower innovation through trusted data flows and to enable international cooperation between law enforcement authorities and private operators.

The EU is leading the world in data protection. Where it goes, others will follow. So even if you’re not designing/developing for an EU audience, you need to be aware of what’s happening.

What Does All Of This Mean For Companies In The EU?

Companies who operate in the EU need to comply with GDPR or risk being fined. Those fines can be pretty hefty, as we’ve seen. So you need to be able to demonstrate that you’re adhering to GDPR’s 7 principles and to specific guidance from your national Data Protection Authority.

However, that’s not as straightforward as it sounds, and you may choose to evaluate your risk in some cases. I’ll take you through an example of that next time.

What Does This Mean For Companies Based Outside The EU?

The implications for companies based outside the EU are exactly the same as those for EU countries, if they process personal data from the EU. That’s because GDPR applies to the personal data of people based in the EU. If you want to process it, e.g. to sell to customers in the EU, you have to abide by the rules. Otherwise, you risk being fined, like Facebook and Google.

Here’s how that’s enforced: If you have a presence in the EU, as many multinationals do, and you don’t pay a GDPR fine, your EU assets may be seized. If you don’t have a presence, you’re obliged under GDPR to appoint a representative in the EU. Any fines will be levied through that representative. Alternatively, you may face a complex and expensive international lawsuit.

And here’s where it gets complex for everyone:

If your customer base includes people in the EU and citizens of other places with privacy laws, such as the State of California, you have to comply both with the California Consumer Privacy Act (CCPA) and with GDPR. These batches of legislation generally align — but they don’t match.

Take cookies, for example. Under
GDPR, you must get active consent from a user before you place a cookie on their device, bar those strictly needed for your site to function.

However, under the CCPA, you must disclose what data you’re collecting, and enable your customer to deny you permission to sell their data. But they don’t have to actively agree you can collect it.

That’s why the EU is pushing for international standards to simplify global compliance.

N.B. If you’re in the United States and eagerly awaiting the replacement to Privacy Shield, you might like to take a leaf from Microsoft’s book instead — they and others have stated they’ll comply with GDPR rather than depend on any bilateral mechanisms to enable data processing.

What Lessons Can Web Designers And Developers Learn From GDPR?

Privacy regulation is here to stay and it affects all our priorities and workflows. Here are six lessons to remember as you work with customer data:

We had to sprint to comply with GDPR. Now it’s a marathon.
We know that GDPR will continue to evolve alongside the technology it aims to regulate. That means the demands on us won’t remain the same. Not only that, but GDPR has inspired similar — but not identical — legislation around the world. These legal requirements are set to keep evolving.
Compliance builds competitive advantage.
While the first major GDPR fines have been eye-watering, it’s actually the negative publicity that many say is most damaging. Who benefits from a large data leak? The company’s competitors. On the other hand, if you embed GDPR compliance as you strengthen your design and development processes, you’ll be better able to adapt as the regulations evolve.
GDPR compliance and better COVID-19 outcomes are linked by user-centred design.
We know that companies who’d begun their digital transformation were better able to adapt to the COVID-19 crisis. User-centred design supports GDPR, too. It has the process and customer focus you need to build products that align with the idea that customer data is precious and must be protected. That will make it easier to evolve your products in line with future legislation.
You can build compliance into your digital products.
Privacy by design is here to stay. If you already use service design, you can include customer information as a data layer in your service blueprints. If you don’t, now’s a great time to start. Mapping where data is collected, processed and stored highlights weak points where potential breaches may occur. Automated compliance tools will help lessen the burden on companies, plus has the potential to make data processing more secure.
GDPR supports innovation — if you do it right.
Some warn that GDPR is suffocating innovation by restricting data flows and especially by deterring companies from innovating with data. Others point to opportunities to innovate with blockchain, IoT and AI in a way that’s secure and where data is protected. The truth? Yes, of course, you can innovate and be GDPR compliant. But ethics in AI is vital: you must respect your customers and their data.
Keep an eye on your third-party partners.
This goes back to the joint controllers decision above. Companies now share responsibility for customer data with any third parties who process it and that processing must be documented. You can expect third-party checks, monitoring and contractual obligations to be a priority for companies from now on.

Here’s How GDPR Could Develop

Phew. That’s a lot to take in. But looking ahead, here’s where I’m betting we’ll see change.

GDPR will continue to evolve, with clarity coming from test cases and potentially further legislation including the ePrivacy Regulation.
The EU will continue to promote international adoption of data privacy law. We’ll see more countries embrace data protection, often baked into trade and security agreements.
If we’re lucky, we may start to see international convergence of data privacy legislation — especially if the US implements data privacy at the federal level.
But we’ll also see more clashes between the EU and the US, because of their opposite approaches to privacy.
As ‘data is the new oil’, we could see more situations where users receive free products and services by giving away data through cookies.
Businesses will shift away from third-party cookies and towards server-side tracking and automation, in order to stay compliant.
Businesses will adopt Privacy by Design (PdB) and service design tools and process, to help them stay compliant to multiple sets of privacy laws.
And finally — and this one’s a definite — we’ll see more and bigger privacy lawsuits. Who’ll emerge as the winners — big tech or privacy advocates? That I don’t know, but we can be certain of one thing: privacy lawyers will make a lot of money.

A Final Word On Trust

The theme underpinning both the European Commission’s communications and the commentary from industry experts is trust. Digital agencies like ours now need to provide evidence of data security and GDPR compliance — even down to staff training policies for data protection. That’s new. The EU’s priority is to support safe, secure data flows and innovation, both within the EU and outside. Standards compliance is their solution for this. And we, as designers and developers, have a crucial role to play.

Part 1: GDPR, Key Updates And What They Mean
Part 2: GDPR, Cookie Consent and 3rd Parties (next week)
Subcribe to our newsletter to not miss it.

Further Reading

Data Protection, the EU’s site
UK ICO’s Guidance On Cookies
GDPR Enforcement Tracker, logs fines applied under GDPR
GDPR Checklist, by Cyber-Duck (a great place to start)
Overview of Data Protection Law in the United States, by ICLG
GDPR & CCPA Comparison Guide, by DataGuidance and the Future of Privacy Forum
CCPA vs CPRA, from IAPP
Security By Design (Amazon)
How To Protect Your Users With The Privacy By Design Framework, Heather Burns, Smashing Magazine

20 Best New Websites, February 2021

/0 Comments/in /by

Original Source: https://www.webdesignerdepot.com/2021/02/20-best-new-websites-february-2021/

It’s February, and the spring sun is finally starting to peep through the winter clouds. While many of us are still largely restricted to our homes, the web has kept on growing.

We see a shift in attitude towards natural health, wellbeing, and sustainability, and these are now being branded less often as outliers and increasingly mainstream. We’re also seeing more and more color all the time, ranging from an emotional signifier in the background to being a functional element in its own right.

GOOD Meat

Gorgeous color in the background image and the scrolling narrative pull the user in on this site for lab ‘grown’ meat.

Hanwag 100 Years

This page celebrating 100 years of outdoor footwear company Hanweg uses a mix of illustrations and photographs to create a timeline marking the company’s highlights alongside what else was happening at the time. Any excuse to get Yoda in.

Gaffer

Gaffer describes itself as bridging the gap between football, music, fashion, and culture. The site has a glossy feel, with strong art direction and an easily navigable architecture.

Remember MLK

This rather beautifully made tribute to Martin Luther King uses some great typographic effects, and the variations, in contrast, create a layering of the different content elements.

Bonjour Agency

The home page for design agency Bonjour Paris uses sideways scrolling to give an overview of the whole site. There is a lot of content, but it doesn’t feel like waffle, and exploring the site is a pleasant experience in itself.

Wild Souls

Wild Souls is a Greek company that principally makes nut butters, tahini, and halva. The site is very colorful but warm, and the display type — Canela — has a slight softness to it that is appealing.

Nicolas Loureiro

This is a strong portfolio site for interactive and graphic designer Nicolas Loureiro. The work is front and center, and the navigation is pleasing.

Studio Nanna Lagerman

Studio Nanna Lagermann is a small interior design studio that works on private homes, public spaces, and set design. The site creates a feeling of space and calm. Colors are soft and neutral, and the type, although massive in places, is clean and sophisticated.

Aurelia Durand

Illustrator Aurelia Durand created her own typeface that she uses in her work, and it is used as the main display font here too. This site has a sense of joy about it that is hard to resist.

Archivio Mario Russo

This site documents the life and work of 20th-century Italian artist Mario Russo. The layout is thoughtful, and the text, while informative, doesn’t detract from the work being shown.

Gigantic Candy

Gigantic Candy makes vegan chocolate candy bars. The site is big, bold and lo-fi, and has a sense of fun to it.

dBodhi

dBodhi sells handcrafted furniture from Java, made from reclaimed teak and locally grown plant materials. The clean layout combined with a slight sepia tone on all the photography creates a feeling of quietness and nature.

Menu Durable

Menu Durable is a guide to creating healthier, sustainable food menus in Canadian healthcare facilities. There is a lot of information here, and it is well written and attractively presented with clear color coding.

Virgile Guinard

This is a lovely, simple portfolio site for photographer Virgile Guinard. By using blocks of color pulled from each photograph’s predominant color and only revealing each photograph on rollover, each image is allowed to stand out.

The Bold Type

This site for The Bold Type Hotel in Patra, Greece, is a boutique hotel website archetype, but it is done well. The pinky sand background color is a good choice, and the photographs are excellent.

NOR NORM

Nor Norm provide an office furniture subscription service. The site is clean with a feeling of light and space. There is a good balance between an overview of the process and details of the individual items available.

Ask Us For Ideas

At first glance, Ask Us For Ideas looks like a creative agency, but it is actually a creative broker, matching clients with agencies.

Prinoth Clean Motion

Prinoth has been making snow groomers since the 1960s, and this microsite is to mark the launch of their new hydrogen and electric versions. It is as slick and glossy as any luxury car website. And now I know what a snow groomer is.

Pschhh

Design agency Pschhh has embraced the use of circles, reflecting the sound of bubbles their name suggests.

CōLab

CōLab is a design and marketing firm. There is a great use of color and movement here, and you don’t really notice initially that there is no actual work on show.

Source

p img {display:inline-block; margin-right:10px;}
.alignleft {float:left;}
p.showcase {clear:both;}
body#browserfriendly p, body#podcast p, div#emailbody p{margin:0;}

The post 20 Best New Websites, February 2021 first appeared on Webdesigner Depot.

Collective #649

/0 Comments/in /by

Original Source: http://feedproxy.google.com/~r/tympanus/~3/H68nr62k0g4/

Inspirational Website of the Week: Wild Souls

A beautiful font pairing and saturated colors make this design really inviting. The result of a fantastic collaboration between Big Horror and No Matter.

Get inspired

Collective 643 item image

Our Sponsor
Instant websites for your clients with Divi Layout Packs

With the Divi Layout Packs you’ll get world-class designs ready to be used for your client projects.

Check it out

Page Transitions: Creative Examples, Resources and some Tips

Dive into the world of transitions and get inspired by wonderful examples and creative ideas.

Check it out

Penpot

Penpot is the first Open Source design and prototyping platform meant for cross-domain teams.

Check it out

Managing focus in the shadow DOM

Nolan Lawson describes what JavaScript libraries for focus management would need to do to support shadow DOM.

Read it

SmolCSS

Minimal snippets for modern CSS layouts and components, created by Stephanie Eckles of ModernCSS.dev.

Check it out

Remotion

Create MP4 motion graphics in React. Leverage CSS, SVG, WebGL and more technologies to render videos programmatically with this tool.

Check it out

Understanding Z-Index in CSS

A visual guide on how z-index and stacking contexts work in CSS.

Read it

The CSS File Size and Count Report for Premier League sites

An interesting file size report of CSS used on Premier League sites. Silvestar Bistrovi?.

Check it out

github1s

One second to read GitHub code with VS Code. Just add 1s after github and press Enter in the browser address bar for any repository you want to read.

Check it out

Building a Tabs component

A foundational overview of how to build a tabs component similar to those found in iOS and Android apps.

Read it

Fitting Canvas Snow In a Tweet

Jon Kantner shows how to code up a really nice snow effect with minimal code.

Read it

Programmatically Generate Images with CSS Painting API

Viduni Wickramarachchi’s tutorial about the CSS Paining API and how to use it to generate a geometric image programmatically.

Read it

The web didn’t change; you did

A very interesting article by Remy Sharp where he explains why “the problem with developing front end projects isn’t that it’s harder or more complicated, it’s that you made it harder and more complicated”.

Read it

Only CSS: Placer Gold Rush

A beautiful CSS demo made by Yusuke Nakaya.

Check it out

Faster JavaScript calls

Victor Gomes explains how the simple idea helped improve performance of JavaScript calls.

Read it

CSS Border Font

A supercool CSS based font made by Davor Suljic using borders.

Check it out

Managing CSS Z-Index In Large Projects

Steven Frieson shares an easy-to-implement mini-framework based on existing conventions for better managing z-index in larger projects.

Read it

CSS Switch-Case Conditions

Yair Even Or explains how to emulate switch-case conditions in CSS.

Read it

How to Greatly Enhance fetch() with the Decorator Pattern

Dmitri Pavlutin writes about how to use the decorator pattern to enhance the possibilities and flexibly of the fetch() API.

Read it

Is CSS float deprecated?

Robin Rendle explains why we can pack away float and only use it for making text flow around images.

Read it

Dialy: Open source UI Kit for Figma

Dialy UI Kit is a free, open source User Interface Kit for Figma, designed and released by Aayush Gupta.

Check it out

Front-of-the-front-end and back-of-the-front-end web development

Brad Frost writes about the much-needed distinction between the types of web development that need to occur in order to build successful web things.

Read it

Accessing hardware devices on the web

François Beaufort explains how to pick the appropriate API to communicate with a hardware device of your choice.

Read it

From Our Blog
Ideas for CSS Button Hover Animations

Some inspiration for button hover animations using CSS only.

Check it out

The post Collective #649 appeared first on Codrops.

App Design Workout,Stay In

/0 Comments/in /by

Original Source: http://feedproxy.google.com/~r/abduzeedo/~3/DQWlx802u78/app-design-workoutstay

App Design Workout,Stay In
App Design Workout,Stay In

abduzeedo02.22.21

Elvis Benício shared a visual proposal for a WFH (“workout” from home) fitness app that helps people to build healthy habits. Both visuals and typography were inspired by the concept of the body movement creating a narrative across branding and product. The result at once communicates, contains, and embodies the inclusion of fitness for everybody. The visuals are clean and the bold typography gives it the app design a nice editorial look.   

Image may contain: abstractImage may contain: screenshot and posterImage may contain: screenshot, mobile phone and internetImage may contain: illustrationImage may contain: cartoon, sign and typography


Interaction Design for SYYNCC App, a Multicam editing tool

/0 Comments/in /by

Original Source: http://feedproxy.google.com/~r/abduzeedo/~3/OpzVLnlY2JU/interaction-design-syyncc-app-multicam-editing-tool-0

Interaction Design for SYYNCC App, a Multicam editing tool
Interaction Design for SYYNCC App, a Multicam editing tool

AoiroStudio02.21.21

With the market we have today, it’s not every day you stumbled across an app that gives you that impression that is a cool idea. But after a few surf on the subject, it also deserves much more exposure. Well it’s the case with SYYNCC, a Multicam editing app designed by Alexander Plyuto. It’s basically an app that as I quote “main functionality is to intelligently adjust video of a single moment taken from different angles.” It would very interesting to give it a try, props on the work by Alexander and team.

plyuto.design
behance.net/plyuto
Check out the SYYNCC app

Image may contain: screenshotImage may contain: screenshot

Image may contain: screenshot

Image may contain: screenshot

Image may contain: screenshot, mobile phone and video game

Image may contain: screenshot, video game and computer

Image may contain: screenshot, black and computer

Image may contain: screenshot

Image may contain: screenshot and person

 


How ImageEngine can Optimize Contentful CMS For Faster Web Performance

/0 Comments/in /by

Original Source: http://feedproxy.google.com/~r/tympanus/~3/doPXNHjvdbU/

A headless CMS is a content management system with only a back-end configuration. The content repository is accessible through a RESTful API for display on any platform. The only focus is to create, manage and deliver structured content wherever it’s needed. Contentful is a headless content infrastructure, especially designed so that everyone without writing code can publish or update the content. It has a separate images API to handle images as it’s a powerful way to attract user’s attention and have the potential to create an impact. In this article, we will review how ImageEngine’s API can transform images better than the native API of Contentful. ImageEngine displays images the way users want and creates a faster website.

How Does Contentful API Manage Images?

Contentful image API refers to images as assets and allows manipulation and retrieval of image files. The asset URL is appended with a specified field to convert and manipulate the image file. An image of more than 20MB is treated as an asset and its size is reduced for uploading. The contentful API image processing includes:

1. Retrieval

The original image can be retrieved from that same asset’s URL.

2. The image can be converted to a different format

JPEGs: Image detail progressively improves until it’s downloaded fully and displays the image as quickly as possible.

PNGs: The PNG is an 8-bit image format, supports up to 256 colors, and is mostly used for simple icons or images.

WebP: This format compresses images on the web while providing a rich image of superior quality.

3. Resizing and cropping the image

Crop: The image can be resized to the required width and height. Images up to 4000 pixels can be uploaded.

Resizing: Resize images with specific dimensions through the padding, filling, scaling, dropping, or thumbnail.

Specify focus: The focus area can be selected for resizing. The values accepted are center, top, right, left, bottom, top_right, top_left, bottom_right, bottom_left, face, and faces. The circle radius in pixels is taken to crop the image for rounded corners.

4. Manipulate Image

The image quality can be altered and can be expressed in percentage. Set the RGB values for background color while setting the pad fit type and corner radius.

How Does ImageEngine Manage Images?

ImageEngine’s image management process adopts next-level optimization techniques to help websites achieve maximum performance. The developer might need to modify the HTML of the site to change the way images are displayed in native apps.

ImageEngine provides automatic image optimization based on client hints, WURFL device detection, and information such as resolution, optimal size, format, and compression. Its auto-mode supports diverse sizes, resolution, and much more which is compatible with desktop and mobile as well. It ensures that the user will get a quality image in the lowest possible size.

ImageEngine’s CDN receives an image request and then carefully searches for efficient edge servers. The servers detect the requesting browser and device to extract details such as:

Device screen sizeScreen resolutionDevice pixel ratioViewport sizeSupported image formats

So it generates different versions based on device size, capability, or compression rate. It embeds unique edge servers and its cache serves fast service even with several versions.

Format Conversion

After the device detection, the most suitable image format is automatically chosen. It’s performed through manual verification, WURFL device detection, and advanced systems. It confidently converts the image to a device supported format while reducing its size to improve the website experience.

Resizing

To provide a great user experience, the image is resized perfectly to fit in the viewport. With the help of client hints, it can handle Retina like high-resolution displays and would make sure to serve the appropriate image size according to the needed pixel size.

Metadata & Compression

The embedded metadata is removed for image optimization. Image compression is performed according to device screen size without compromising the image visual quality.

Client Hints

The Blink-based browsers support client hints, and it sends viewport details for generating perfectly optimized images. With this information, ImageEngine will automatically deliver the lowest possible file size with the best visual quality.

How to Integrate ImageEngine to Contentful?

It’s easy to integrate the ImageEngine image optimization API with Contentful to manipulate, convert, and transfer the image files for quick retrieval. To configure ImageEngine API with Contentful:

Step 1: Sign up for an ImageEngine Account to get started with optimizing images and obtaining a delivery address for faster web page loading.

Step 2: Next, define the origin of the images. Enter the URL of the Contentful-powered website, or simply enter the Contentful API base URL: images.ctfassets.net (read-only) as image origin location.

Step 3: An ImageEngine delivery address is generated. Copy this delivery address.

Step 4: Update the image tags to direct image requests to ImageEngine by replacing any occurrences of the default Contentful image API (images.ctfassets.net) with the new ImageEngine delivery address just provided.

For example, if the original image tag looked like this:

<img src=”https://images.ctfassets.net/yadj1kx9rmg0/wtrHxeu3zEoEce2MokCSi/cf6f68efdcf625fdc060607df0f3baef/quwowooybuqbl6ntboz3.jpg”/>

Then modify the image tag URL with the ImageEngine Delivery Address to look like this:

<img src=”https://<ImageEngine-Delivery-Address>/yadj1kx9rmg0/wtrHxeu3zEoEce2MokCSi/cf6f68efdcf625fdc060607df0f3baef/quwowooybuqbl6ntboz3.jpg”/>

Contentful Image API vs ImageEngine Image API

Contentful API Image

The Contentful optimized image has a content length of 46967 bytes in PNG format. As shown below.

ImageEngine Optimized Image

The ImageEngine optimized the same PNG image to WebP format and reduced content length to 7924 bytes. As shown below.

Therefore, ImageEngine compresses the image far better than the Contentful without compromising with the content quality.

Thus, by directing image requests to the ImageEngine Delivery Address, ImageEngine will automatically detect the device, optimize the image, and deliver via its global server network. This will greatly accelerate image loading time, decrease the physical distance between the user and content cached on the network, and maintain the image quality.

Step 5: Tune-up the account with the help of the ImageEngine control panel. The settings can be modified, set engine origins, and customize the delivery addresses.

Let’s compare ImageEngine’s image and Contentful published image.

Contentful
ImageEngine

JPG Format – 629 KB
JPG Format – 314 KB

PNG Format – 631 KB 
PNG Format – 387 KB

WebP Format – 329 KB
WebP Format – 297 KB

As you can see, the image size published by Contentful is significantly larger than ImageEngine’s optimized image, but there is negligible visual difference between the two. In addition to these formats, ImageEngine can also convert images to the new AVIF format which is not possible with Contentful API.

Conclusion

Organizations can integrate Contentful CMS with ImageEngine’s image optimization API and CDN to gain competitive advantages. One such advantage is climbing to the better spots on the search engine result pages. The faster speed has a direct connection with the improved user experience of the website and when the user experience improves, it improves the core web vitals that help in the achievement of goals related to the long-term presence on search engines.

The post How ImageEngine can Optimize Contentful CMS For Faster Web Performance appeared first on Codrops.

Plum – Branding and Visual Identity for Food Delivery

/0 Comments/in /by

Original Source: http://feedproxy.google.com/~r/abduzeedo/~3/zLpYsTXrUgw/plum-branding-and-visual-identity-food-delivery

Plum – Branding and Visual Identity for Food Delivery
Plum - Branding and Visual Identity for Food Delivery

abduzeedo02.18.21

Judy Chen and Crystal Ho shared a branding and visual identity project for Plum, a lifestyle curator that shares their taste via their food delivery app. Like harvesting ripened and succulent fruit while filtering out the rest, the team thoughtfully selects products based on quality, affordability, and distinctiveness. The result is a refined collection of the best — tasted by experts, with insider prices, and customised to each individual’s preference. The identity is the expression of consumer decisions made easier.

Credits

Agency: A Work of Substance


Useful DevTools Tips And Shortcuts (Chrome, Firefox, Edge)

/0 Comments/in /by

Original Source: https://smashingmagazine.com/2021/02/useful-chrome-firefox-devtools-tips-shortcuts/

Out of all the tools available at our fingertips these days, DevTools is probably one of the most advanced ones. Over the years, it has become a tool for debugging, profiling, auditing and even prototyping — all living within the same interface, and always just a keyboard shortcut away. Still, DevTools has plenty of obscure gems and undiscovered treasures, living on the remote fringes of hidden tabs and experimental settings. Let’s fix that.

In this article, let’s dive into some of the useful and obscure features in DevTools. We’ll look into all modern browsers (Chrome, Firefox, Edge, Safari) and look into the useful tools that they provide to us, web developers. We’ll focus on the ones that we use frequently on SmashingMag, and some of the little techniques and strategies that help us fix pesky bugs and write better code.

Creating Browser Profiles

When it comes to profiling a website for performance, or tracking a particular accessibility issue, we’ve been creating separate browser profiles for each task for a while now. We usually work with at least 5 user profiles, each with its own extensions, bookmarks, bookmarklets and features turned on or off. Let’s take a closer look at them.

Accessibility profile
A clean browser profile that includes various tools for checking accessibility, e.g. Accessibility Insights, aXe and a11y.css, along with a few other accessibility linters and color vision simulator.

Debugging profile
A profile with a few experimental settings for profiling turned on, as well as an option to automatically open DevTools for every new window, along with a custom diagnostics CSS for quick auditing and profiling.

Performance profile
A clean profile without extensions, with a few special bookmarks for auditing with Lighthouse, RequestMap, a performance diagnostics CSS and a few performance-related links to keep in mind (e.g. resource priority in loading). Always goes well with 4 × CPU throttling and Network throttling (Slow 3G).

Happy customer
Based on the data we have from our analytics, that’s a profile that is close enough to the one that many of our readers (wonderful people like you) will have. It will contain a few popular extensions, common web development extensions, ad-blockers, tab management, Google Docs offline, LastPass, VPN, Browserstack, Grammarly etc. No throttling in use.

Unhappy customer
A profile for a reader on a slow, throttled connection (slow 3G), low memory, poor CPU, with 10 most popular browser extensions on. We usually use this profile to test our heaviest pages to experience the worst possible customer experiences.

Depending on the task at hand, we can jump to one of the dedicated profiles. The actual convenience comes from the simple arrangement that each of the profiles has specific extensions, bookmarklets and browser settings all set and ready to go. So if needed, we can get right to performance debugging or accessibility auditing without any hassle for searching the right extensions.

It probably goes without saying that we do our best to keep each profile clean and uncluttered — that goes for browser extensions as well as browser bookmarks, cookies and cache.

Global Keyboard Shortcuts

Admittedly, with the sheer amount of features available in DevTools, it’s not very surprising that some of them are quite difficult to find between tabs, panels, gear icons and dots. However, there is no need to memorize the place where they are placed. Instead, it’s worth remembering just a couple of useful global keyboard shortcuts — they will help you jump to specific features faster.

Opening the Command Menu (Chrome, Edge)
Being probably one of the most well-known ones, this command actually has two features. Cmd/Ctrl + Shift + P opens a quick autocomplete search for panels, drawers and all the features within DevTools. Cmd/Ctrl + P opens a drawer with all available files used on the current page. If you need to quickly access any DevTools feature, the Command Menu is a quick way to get there — for general drawers, hidden menus or specific features.

Opening DevTools Settings (all modern browsers)
Usually there are plenty of obscure tools and features hidden in the “Settings” panel — from emulated devices to network throttling profiles and experiments. In Chrome, you can click on the gear icon in the right upper corner or use Shift + ?. In Firefox, you can jump to Settings with F1.

Toggle Inspect Element Mode (all modern browsers)
Instead of clicking on an Inspect icon and then focusing on the element you’d like to debug, you can toggle Inspect Element Mode with Cmd/Ctrl + Shift + C.

Toggle the HTML mode (all modern browsers)
While inspecting an element, you might want to change its attributes, e.g. classes or states. Instead of right-clicking on the element and adding values one-by-one, you can toggle the HTML mode on the currently selected element with Fn + F2 (or just F2 on Windows).

Toggle Device mode (all modern browsers)
To jump into the device toolbar mode, e.g. to preview how the mock-up looks like on narrow screens, or trigger a media query debugger, you can use Cmd/Ctrl + Shift + M in Chrome, and Cmd/Ctrl + Opt/Alt + M in Firefox.

There are also plenty of other useful keyboard shortcuts, e.g. for pausing and resuming script execution, and go to matching bracket (for lengthy media queries and JS functions) in the source editor.

You can find a full overview of all keyboard shortcuts on Chrome DevTools Keyboard Shortcuts and Firefox DevTools Keyboard Shortcuts — more often than not, they are quite consistent across modern browsers.

Turn On Experimental Settings

DevTools comes along with a set of experimental settings which aren’t quite recommended for a wide audience, but can indeed be very useful for debugging. A word of caution though: sometimes these settings might freeze Chrome or make it quite sluggish (which is why they are experimental in the first place).

However, with separate profiles in place, you could safely turn on some of these settings for each profile, and then turn them off if necessary. So while we use our regular profiles without experiments turned on for casual browsing, in debugging mode we always pick a dedicated profile first, to squish those bugs just a little bit faster.

With DevTools open in Chrome, jump to “Settings” (Shift + ? with DevTools open) and find “Experiments” in the sidebar. Obviously, there are plenty of experimental settings available in every DevTools, but the ones mentioned below are just the ones we find quite helpful at our work.

Across the featured listed there, it’s worth turning on “Automatically pretty print in the Source Panel”, which would prettify compressed styles and scripts by default when viewing source. You can also enable CSS Grid debugger and Flexbox debugging for dealing with layout issues. There is also a source diff and a source order viewer that can come in handy.

And for performance audits, you could mark “Timeline: event initiators” and “Timeline: invalidation tracking” that will show in the Performance panel, highlighting scripts that caused expensive operations such as Long Tasks and Style Recalculations. Additionally, in Edge, you can enable composited layers in 3D view.

For a given profile, you can access more hidden features by heading to chrome://flags/ in the browser profile of your choice. for example, that’s where you can turn on latest and experimental JavaScript features, experimental Web Platform features or enable resource loading hints to provide a preview over slow network connections.

In Firefox, jump to Settings with F1. At the bottom of the dock, you can prompt the browser to show browser styles, turn on/off autocomplete CSS, change editor preferences, toggle paint flashing, adjust screenshot behavior and enable source maps (not turned on by default). In Safari, you can find Experimental Settings under “Develop → Experimental Settings”.

Switching Between Dock States (Chrome, Edge, Firefox)

Admittedly, the pane view in DevTools isn’t a particularly big revelation. In the “Styles” tab of the dock, styles appear from top to bottom, ordered by their CSS specificity. However, one little thing we’ve been overlooking a lot for years is a little toggle button :hov placed just above the styles.

It allows you to force an element state (:active, :focus, :focus-within, :hover, :visited and :focus-visible, and most recently :target) on a particular interactive element — e.g. to enforce :focus and :active states on buttons for accessibility checks.

In Firefox, you can change a pseudo-class for a DOM element as you are inspecting it — the feature is available with a right-click on a DOM node.

One thing that always gets in the way though is the position of the dock, which sometimes works better on the right hand side, and sometimes at the bottom — depending on where your bug has invaded your DOM tree.

To quickly switch between dock states, you can use Cmd/Ctrl + Shift + D. One catch to keep in mind is that the shortcut will undock DevTools into a separate window only if DevTools has been in its default position (docked to the right). Otherwise the shortcut will just switch between the default position and the one you’ve changed it to.

Triple Panes View (Firefox)

While we might be used to a double-pane view, Firefox provides a helpful triple-panes-view by default — it looks slightly differently across different sections. In the Inspector view, alongside HTML and styles you can place layout debugger, show computer styles or track CSS changes — it’s very useful to have quick access to all this information without having to switch between tabs.

Whenever you are editing styles in Firefox, DevTools highlights media queries used across the page, with quick jumps to CSS sections where a breakpoint behavior is defined. All of it is displayed right next to the source code, so no need to search for a specific breakpoint. (Not to mention styles pretty-formatted by default — that’s handy!).

A similar view is also available in Chrome and Edge as well, but it’s available only in the “Elements” panel (sidebar icon in the right upper corner), and so far it shows only computed styles (which is why it’s called “Computed Styles Sidebar”).

Filtering Styles By Property (Firefox)

In general, Firefox DevTools are heavily underrated. Another remarkable feature that Firefox provides is an option to filter all styles by a particular property (indicated with a filter icon). For example, if you notice that some styles are overwritten by other ones scattered somewhere across the stylesheet, you can hide all the definitions that don’t affect that particular property with a quick filter and see where exactly overrides are happening.

Also, on a given page, you can highlight all instances that match a particular selector. For example, if you notice a bug with a rendering of profile images on dark and light sections of the page, you can highlight all instances of a particular class without manually searching for them or adding extra styles to highlight them. It’s enough to locate the selector in Styles panel and choose a target icon to “highlight all elements matching this selector”.

In the “Styles” panel, Firefox also explains which CSS properties aren’t affecting the selected element and why, along with recommendations of what might help to fix the issue or avoid unexpected behavior (the feature is called Inactive CSS).

Another handy feature is that Firefox assigns scroll and overflow badges to elements that are causing the container to overflow or scroll (overflow debugging) — very helpful when you are trying to figure out why a horizontal scrollbar appears all of a sudden, or an element doesn’t behave as expected.

Expanding Nodes Recursively (Chrome, Edge, Firefox)

When inspecting an element with a deeply nested DOM, sometimes it might take a while to traverse down the tree, from one nested node to another. By right-clicking on the arrow on a node, you can choose “Expand recursively” and the currently-selected node (and all of its children) will expand with one single click. Alternatively, you can hold Option (or Ctrl + Alt on Windows) while clicking the arrow icon next to the element’s name.

Gather And Export Code Coverage (Chrome, Edge)

On a given page, much of the CSS and JavaScript might not be used at all, although it will be shipped to the browser. The “Code coverage” panel (Command menu → “Show coverage”) allows you to explore which styles and code aren’t used on a given page. We use code coverage to collect critical CSS for each of the templates used on the site, and doing so manually can be quite tiring.

With “Code coverage” in place, going through a couple of scenarios that include a lot of tapping, tabbing and window resizing, we also export coverage data that DevTools collects as JSON (via the export/download icon). On top of that, you could use Puppeteer that also provides an API to collect coverage (but we aren’t there yet).

Media Queries Debugging (Chrome, Edge)

With dozens of media queries in flight for a given page, it can easily become difficult to keep track of the styles being overwritten by other styles scoped within a media query. To find the specific section in your CSS file that might be causing unexpected behavior, we could turn our attention to the media query debugger. By default, it’s hidden away behind the “Settings” cog in the device toolbar, but it’s actually quite helpful when it’s available by default.

Toggle the device toolbar (responsive mode) with Cmd/Ctrl + Shift + M and choose the three dots in the right upper corner. Then choose “Show media queries”. Now you should be able to see horizontal bars representing the scope of each media query.

They might appear a bit confusing at first, but the way these bars are aligned represents screen width, and is replicated on the left and on the right side of the viewport. The bars closer to the center of the screen are overwritten by the ones further away from the center. The blue bar on the top indicates max-width media queries, the green one min-width and max-width media queries, and orange one stands for only min-width media queries.

For all of the bars, you can track which media queries they contain when hovering over them. You can jump to a specific media query range and inspect layout issues in detail with Styles panel open. By clicking on any position on a bar, you can trigger specific breakpoints, and if you right click on a bar, you can reveal its position in the source code. In fact, you can quickly jump back and forth between media queries, rather than resizing the screen manually and checking the screen width over and and over again.

As a quick side note, you can also specify your custom emulated devices instead of the pre-defined ones — in fact, there are plenty of device presets available already. Plus, you can use the “Sensors” pane to control specific device sensors if needed. Additionally, in Firefox you can enable and disable touch simulation, and define a specific User Agent, e.g. to check how the page behaves with a search engine crawler requesting the page.

Emulate Preference Media Queries (Chrome, Edge, Firefox)

Additionally to screen size-related media queries, we can also emulate accessibility-specific media queries, e.g. prefers-color-scheme, prefers-reduced-motion and vision deficiencies. To toggle the emulation, head to the Command Control panel (Cmd/Ctrl + Shift + P) and type “Show rendering”. Now, in the settings you can choose a preferred emulation.

(That’s also where you can choose to highlight areas that need to be repainted (“Paint Flashing”), areas that have shifted (“Layout Shift Regions”) and debug scrolling performance issues.)

Talking about emulation: remember how in the past you might have struggled with finding a layout bug for you print stylesheet? In the same panel, you can preview how your print styles work here as well — no need to print a PDF of a random page over and over again to figure out what caused a major rendering issue any more.

Also, in the same panel in Chrome you can add all sorts of rendering debugging features — e.g. paint flashing, layer borders, scrolling performance issues, disabling AVIF and WebP.

As a side note, there is a DevTools toolbar option for “Force Dark Appearance” and a “Force Print Media styles” in Safari, and you can simulate vision deficiencies in the “Accessibility” tab in Firefox. (We’ll talk a bit more about Accessibility later.) In Firefox, the print view is also available above the “Styles” pane in the “Inspect” mode.

Automatically Open DevTools In Each New Tab (Chrome)

With performance audits, we might want to be exploring multiple page at once, and observe how they behave with separate DevTools, without having to wondering which DevTools is responsible for which window. To save a bit of time during debugging, you could create a shortcut with a Terminal command that would open a browser with DevTools automatically opening by default in each new tab.

To achieve that, we need to pass the flag –auto-open-devtools-for-tabs when running a Chrome, Edge-based browser. We run a simple Alfred script to open the Canary browser with the flag when needed (hat tip to Addy) — very useful when you really need it:

/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary –auto-open-devtools-for-tabs htps://www.smashingmagazine.com

You can find a very comprehensive overview of all Chrome, Edge command line switches in Peter Beverloo’s guide on Chrome Command Line Switches.

Full Page Screenshots (Chrome, Edge, Firefox)

When selecting an HTML node in the “Elements” pane, you could right-click on the node and prompt the DevTools to create a screenshot of that node, and in the “Responsive mode” you can capture a screenshot of the visible portion of the page or a full size screenshot (three dots in the right upper corner).

To create a full size screenshot a little bit faster, you can also prompt a “Full page screenshot” in the Command Menu (Cmd/Ctrl + Shift + P → “Full page screenshot”). Usually it’s a little bit faster. Just keep in mind that portions of the page that are lazy-loaded or rendered progressively (e.g. with content-visibility) might not show up properly in the screenshot, so you might need to scroll all the way down the page first.

In Firefox, you can generate a screenshot of the visible portion of the page by going to the “Device Toolbar” mode first, then spotting the camera icon in the right upper corner and activating it. Or for a full page screenshot, you’d need to toggle “Take a screenshot of the entire page” in “Settings” first, and then you’ll find the camera icon in the DevTools toolbar.

Rulers For Components (Chrome, Edge, Firefox)

Perhaps you’d like to quickly check the width and height of an image, or an advertising spot. But rather than taking a screenshot, or inspecting element and copy/pasting width and height values, you can use a rules to measure the size of a component. Rules are provided all across modern browsers, but Firefox DevTools also allows you to measure a portion of the page. You can find the measurement tool on the right hand side of DevTools, right next to the “Responsive mode” icon.

Tracking Changes (Chrome, Edge, Firefox)

As you are debugging a particular problem, you might have commented out some lines of code, and probably added some new code that seems to be fixing the problem for good. Your changes now have to be replicated in the actual source files. To do that, there is no need to manually collect all the changes you’ve made all across your files.

In Chrome, toggle “Local Modifications” command when editing the source file. You should see a tracker of changes appearing in the panel below. If it’s collapsed, pull it out by dragging it vertically. The pane highlights changed properties and what exactly has changed, so you can copy-paste modifications right away.

One thing to keep in mind is that it’s probably a good idea to track changes while running your local server — without automatic removal of line breaks and spaces as they would show up as changes as well. This problem doesn’t exist in Firefox, where you can also find a “Changes” pane which does the same thing, along with a friendly button “Copy All Changes”.

Local Overrides (Chrome, Edge)

You might have been in this situation before: you just want to experiment with a few changes, but might be quite afraid to accidentally hit “Refresh” in the browser to lose all the changes made on the page. Perhaps you can’t really run the site locally, or perhaps you just don’t want to run your entire build for some minor local modifications. In such cases, Chrome’s “Local Overrides” can be a godsend.

First, create a folder on your machine where all your local modifications will be stored (local-overrides on Desktop seems like a reasonable name and place for this kind of task). Then head to the “Sources” tab, and choose “Overrides” in the top-left corner of DevTools (it might be hidden behind a double-chevron). Now click on “Select folder for overrides” and choose your freshly created folder — that’s the folder that Chrome will be using to store your local modifications. You’ll need to click “Allow” to grant Chrome permissions to save files to your hard drive.

Now, you can choose any file in the “Sources” panel, right-click anywhere in the code and choose “Save for overrides” with the right-click. That’s a clue for Chrome to create a new file, and store all contents of the file, along with your modifications, to your hard drive. (You might want to click the {} button first to make the code slightly more readable). (Thanks to Trys for the hint!)

Once you’ve defined your local overrides, Chrome will intercept network requests and use your code instead of the actual response. It will also watch out for modifications made to the file and inject changes into the page automatically, very much as if you had a local development installed with the watch mode on. Any files that are overwritten by local overrides will have a little purple dot next to them in the “Elements” panel.

The best part: now you can open the file in your text editor and make changes from there, while seeing these changes appearing in DevTools as well — and if you need to switch to DevTools to add breakpoints, you can do it from DevTools, make changes to the code, and these changes will be visible in your text editor as well. Almost magic!

Pro-tip from Harry Roberts: Local Overrides don’t allow you to keep or track versions or variants, but you can attach a query string to the URL and load separate variants of the same page. Extremely useful when editing HTML pages.

Ah, and if you need to disable local overrides again, just check off “Enable Local Overrides” in the same pane — otherwise the styles will overwrite existing styles over and over again, which is something you might not want.

Remote Debugging (Chrome, Safari)

If you need to debug your apps or pages on a mobile phone, you can use a Devtools proxy for iOS devices to debug Chrome on iOS, and also use DevTools to debug Mobile Safari on iOS with Chrome DevTools.

To debug Mobile Safari with Safari Inspector, enable “Web Inspector” in “Settings → Safari → Advanced → Web Inspector” and open the debugger with “Develop” → (Your phone’s name). You should have Safari’s DevTools opening up for you.

For Android devices, open the Developer Options on Android and select “Enable USB Debugging”. On your development machine, you can then discover your mobile device by going to chrome://inspect#devices and choosing your “Remote Target”. You can find plenty of details and instructions on “Get Started With Remote Debugging Android Devices”. That’s also where you can find a dedicated DevTools for Node.js debugging.

Pause Script Execution (Chrome, Edge, Firefox)

When testing critical CSS or debugging JavaScript, you might want to hold on to the state of the DOM before a particular script gets executed or a particular style gets applied. That’s what DOM change breakpoints in DevTools are for.

By right-clicking on the three ominous dots next to the element’s name, you could pick “Break on” subtree modifications (node insertions and removals in the DOM tree rooted at the given node), attribute modifications (e.g. when an attribute is added or removed, or an attribute value changes — e.g. with classes) or node removal.

However, you can also use a conditional line-of-code breakpoint when you know the exact region of code that you need to investigate, but you want to pause only when some other condition is true. Plus, not to forget logpoints to output a value in a code snippet without writing console.log over and over again.

Code Snippets (Chrome, Edge)

If you have a couple of code snippets that you use often to track what might have caused the buggy behavior, you can store and access these snippets in the “Snippets” pane. In a way, these JavaScript snippets are similar to bookmarklets, but unlike the latter, you can manage them from the convenience of a dedicated area in DevTools.

Because they are scripts, we can add breakpoints when these scripts are running, or select portion of your code inside “Snippets” and run that particular portion of the code instead of executing the entire snippet.

The “Snippets” pane is located among “Sources”, next to “Local Overrides”. Once you’ve added a snippet, you can run it either by right-clicking and selecting “Run”, or with Cmd/Ctrl + Enter. Of course, each snippet is available from the Command Panel as well.

In general, if you find yourself running a routine task over and over again, there is a good chance that you might want to place it in “Code Snippets” and automate this task with a script. DevTools Snippets includes some useful scripts for cache busting, showing headers and saving objects as .json files from the console, but you could use it to modify the DOM or display any useful information, such as performance marks (which is what we do). Plus, you could also plug in a performance diagnostics CSS to indicate lazy-loaded images, unsized images or synchronous scripts.

Run Custom Automated Tests (Safari)

One of the often forgotten features in Safari DevTools is the option to define and run a series of automated checks. Think of it as a custom-built testing suite, with a series of small tests, which can be fully defined based on the type of audit a developer would like to run. By default, the test suite is focused around accessibility, but you can adjust it as you see fit, e.g. in order to check if there are any sync scripts in the DOM, or if all of the images have a defined width and height attribute, or even if all images are lazy-loaded. (thanks, Nikita!)

Source Maps (Chrome, Edge, Firefox)

When debugging production code, it’s extremely handy to be able to track down the changes to a specific component or module that you use in your code base. To map minified code to source code, we can use source maps. If you generate a source map as a part of your build, you can use source maps while debugging your code in DevTools.

In Chrome, you need to enable source maps for JavaScript and CSS in “Settings”, and then add a folder to “Workspace”. DevTools with then try to infer all mappings automatically and load your source files in addition to your minified ones. You can then read and debug compiled code in its original source. Even better than that: you can still walk through your breakpoints, and all errors, logs and breakpoints will map to the actual code. To build out your source map, Webpack’s Devtool might help.

For Firefox, once the source map is generated, a transformed file has to include a comment that points to the source map. Just make sure that your bundler does the job for you. Once it’s in place, in the source list pane, the original source (.scss or .ts files) will appear, and you can debug it right there.

Clear Service Worker’s Cache And Storage (Chrome, Edge)

When we hit “Hard Refresh” in the browser, the browser will not use anything from the cache when reloading the page. Instead, it will re-fetch all assets from the server, without relying on caching.

If you right-click the “Refresh” button with DevTools open, you’ll find another option: “Empty Cache and Hard Reload”. The difference is that if the page prompts any dynamic fetches via JavaScript, they might still use the cache. The latter option clears them, too, while the former doesn’t.

Both of these options, however, don’t clear cookie or service worker’s cache — which you might want to do in some scenarios. Jump to the Command menu (Cmd + Shift + P) and type/autocomplete “Clear site data”. When this option is activated, the browser will clean all of the data (as the name assumes), including the service worker’s cache as well as the unregistering of the service worker. (Alternatively, you can click “Clear Site Data” in the Application panel.)

And if you want to delete only cache or only cookies quickly, you can right-click on any request in the “Network” panel, and choose “Clean browser cache” from there.

In Firefox, you’ll need to head to the “Privacy & Security” panel and find the “Cookies and Site Data” section there.

Filters In The Network Panel (Chrome, Edge, Firefox)

There seems to be not much to explore in the “Network” panel as it basically just shows the list of browser requests (along with server responses) in chronological order. However, there are plenty of obscure little helpers as well.

First of all, with an overview of requests in front of us, we can choose which columns we’d like to see. Right-click on the header of one of the columns and select the ones that you find useful for the task at hand. We always choose the “Priority” column to see in which priorities assets are being requested, and if we need to adjust that order to deliver critical assets faster (based on JavaScript Resource Loading Priorities in Chrome, Edge).

We can also filter requests to find specific ones that might be causing trouble (thanks for the tip, Harry). At the top of the “Network” panel you’ll find an input field, which accepts not only keywords but also commands for filtering. Here are a few examples of the useful ones:

is:from-cache shows all resources that were delivered from the cache,
is:service-worker-initiated, shows only requests prompted by a service worker,
is:running shows all incomplete or unresponsive requests,
larger-than:250k shows all resources that are larger than 250 Kb,
-larger-than:250k shows all resources that aren’t larger than 250 Kb (same size and smaller),
mixed-content:shows all assets that are loaded over HTTP instead of HTTPS,
-has-response-header:Cache-Control highlights assets that don’t have any caching headers,
Obviously we can also search for bad practices like document.write and @import in HTML and CSS, plus we can use regular expressions as well.

All filters can be combined as well, separated by an empty space. You can check a comprehensive list of all filters as well, or just type – in the filters input and get an autocomplete preview of all features (huge thanks to Harry for the tip!).

Check Initiators In The Network Panel (Chrome, Edge)

If you want to quickly check which assets a particular resource has requested, or by which resource an asset was requested, there is a simple way to discover it in DevTools as well. This is especially useful in cases where you might have a couple of third-party scripts that might be calling fourth-party-scripts.

When you are inspecting a request in the “Network” panel, hold Shift while hovering over an element. The pink background color will indicate resources that this element has prompted to download, and the green background color will indicate the initiator that actually prompted the request.

Choose a User Agent (Chrome, Edge, Firefox)

Sometimes you might want to check how the page will render with a different user agent, e.g. to make sure that a Googlebot gets a properly rendered version of the page. By heading to “Network conditions”, you can define the behavior for caching, network throttling and a user agent.

By default, the latter is “automatic” but there are 10 predefined groups, ranging from GoogleBot Desktop and Mobile to Android and UC Browser. You can also define your own user agent if you need to. However, these settings will not remain preserved as you navigate from one tab to another.

In Firefox, you’ll need to head to Firefox’s about:config page and define a general.useragent.override string.

Change Scrolling Behavior In The Performance Panel (Chrome, Edge)

At first glance, the Performance panel might appear quite daunting with its flame charts, plenty of data displayed at once, and quite non-conventional scrolling behavior. By default, regular vertical scrolling acts as zooming into a selected portion of the timeline, but we can change it.

In “Settings”, you can switch “Flamechart mouse wheel action” from “Zoom” to “Scroll” — and voilà, your preferred scrolling will be preserved! But what if you wanted to use both zooming and scrolling though? The key hint there is to hold “Shift” while scrolling to toggle the preferred behavior.

Making Sense Of The Performance Panel (Chrome, Edge)

Remember “Timeline: event initiators” and “Timeline: invalidation tracking” we mentioned in the Experimental settings? These experimental features come in handy in the Performance panel when you are looking for a cause of expensive operations — so-called Long tasks (tasks that take over 50ms to complete). The goal then is to break down Long tasks into shorter tasks, and usually it makes sense to focus on the longest Long tasks first.

Jump to the Performance panel and start profiling with Cmd/Ctrl + Shift + E. After a bit of time needed for refresh and collecting data, those expensive long tasks will show up in the timeline, highlighted with a red rectangle in the right upper corner. Their length indicates how expensive the operation actually is. Tasks have a friendly budget of 50ms to finish, which is why the first 50ms-portion of the task is displayed in solid grey. Whenever you are beyond that budget, the rest of the task is highlighted with red/grey stripes.

The flame chart is a visualization of what each task consists of. All parts of a task are displayed under the actual tasks, with a yellow background representing scripting. If you click on “Evaluate script” under each of the tasks, you can pull up the “Summary” drawer at the bottom and see which script caused the cost. If you click on the purple bar labeled “Recalculate style”, DevTools will show what exactly has triggered styles invalidation.

Probably the most underrated feature in DevTools is indeed the “Summary” drawer which would then also show up which elements were affected by style recalculation (so you can jump to them right away) and what has initiated this task in the first place.

Debugging Janky Animations With Layers (Chrome, Edge, Safari)

You just need a couple of animations, perhaps with a little bit of parallax, a sliding navigation or mischievous z-index manipulation, to run into dropping frames and janky animations. The FPS meter from the performance panel (Chrome) will reveal if you are running frames smoothly, but if it isn’t the case, you can explore rendering issues in the “Layers” tab.

Some of the issues can be easily detected by tracking which of the elements are missing a will-change property, and which ones are using a disproportionate amount of memory. That’s how we spotted a large component that was hidden away off the screen with relative positioning of -1000px off the screen, causing a couple of MB of memory usage. Also, when debugging a canvas issue, keep in mind that Safari has a Canvas Memory Usage debugger.

3D View Z-Index Debugger (Edge)

Another helpful tool to track rendering issues and z-index issues is Edge’s 3D View of the DOM (“Settings” → “More tools” → 3D View). The tool provides an interactive visualization of the DOM and z-index layers. You can even choose to view the DOM colored with the actual background colors of the DOM elements or show only stacking contexts.

It really has never been simpler to see how z-index values are distributed across the page, and why overlays or panels don’t appear as expected when triggered.

Better Accessibility Profiling (Chrome, Edge, Firefox)

Wouldn’t it be great to have one-in-all accessibility tool that would provide details and guidance about everything from tab order to ARIA-attributes and screen reader announcements? To get close to that, we’ve set up a dedicated accessibility profile with useful extensions and bookmarklets mentioned at the beginning of the article. However, DevTools provides some useful features out of the box as well.

In Chrome and Edge, the “Accessibility” panel shows the accessibility tree, used ARIA attributes and computed properties. When using a color picker, you can check and conveniently adjust the colors to accommodate for a AA/AAA-compliant contrast ratio (along with the ability to switch between HEX, RGB, HSL with Shift + Click on swatch — thanks Ana!).

As already mentioned, the “Rendering” panel also allows you to emulate vision deficiencies. Lighthouse audits also include a section with recommendations around the accessibility of the page. Plus, when you inspect an element, accessibility information is appearing in the overview as well.

Firefox has advanced accessibility tooling as well. Additionally to the accessibility tree and contrast checker, Firefox DevTools highlights roles and landmarks, along with accessibility recommendations and checks. For example, you can check for contrast issues on the entire page, check if all links are focusable and include focus styling, and review text labels. Plus, you can toggle tabbing order as well.

Additionally, you can install accessibility-focused extensions such as Accessibility Insights, aXe and a11y.css, along with a few other accessibility linters and color vision simulators.

Worth Mentioning

Obviously, there are literally hundreds, and perhaps even thousands, of other useful features available in DevTools. Many of them are quite well-known and don’t need much introduction, but are still worth mentioning.

CSS Grid / Flexbox Inspectors (Firefox, Chrome, Edge)
If you have any layout issue related to Grid and Flexbox, you’ll probably find a cause of the problem via DevTools. Grid and Flexbox inspectors are very useful as they show grid overlay and the boundaries of containers, as well as hints on everything from flex-basis to grid-gap.

Live Expressions
If you’ve been running into habit of typing the same JavaScript expression in the console, you could look into automating it with Live Expressions. The feature, available in Chrome, Edge and Firefox, allows you to type an expression once and then pin it to the top of your console, and the value of the live expression will update automatically.

Animations Panel
Firefox has a very handy panel to track issues with animations, including slowing it down and visualizing how an element is changing over time.

Fonts Panel
Firefox also has a handy “Fonts” panel that’s worth exploring for any kind of font-related issue. We used it quite a lot when trying to match the fallback font against the web font, for example, as you can refine typographic properties with a slider and see impact in action. It also provides text previews when hovering over a font-family in styles.

CSS Overview
If you activate the “CSS Overview” in Chrome’s experimental settings, DevTools will add a tab with a comprehensive report of CSS declarations used on a page. It will also list all colors and fonts used, as well as media queries and unused declarations which you can jump to right away.

And That’s A Wrap!

When we set out to prepare this overview, it was supposed to be quite short, featuring just some of the useful features that DevTools provides. It turned out that there are plenty of features that we didn’t know of before we started writing this article — and we were able to stumble upon them with the kind help of wonderful Smashing readers who contributes their experiences on Twitter. Thank you so much for your kind contributions!

Also, a huge thank-you to all contributors of all DevTools across all browsers — we applaud you for your efforts, and your time and effort to make our development experiences better. It matters.

If we missed something valuable, please reply in the comments. And if you found something useful, we hope you’ll be able to apply these little helpers to your workflow right away, and perhaps send a link to this post to a friend or two — perhaps they’ll find it useful. Ah, and don’t forget: you could also debug DevTools with DevTools — just hit Cmd/Ctrl + Shift + I twice in a row. 😉

Now, happy debugging, everyone!