Why DevTools and screen readers are inconsistentArticle contains
  1. The four-layer pipeline
    1. 1. DOM - developer intent
    2. 2. Browser accessibility tree - browser interpretation
    3. 3. OS-level accessibility API - platform translation
    4. 4. Screen reader interpretation - user experience
  2. Why DevTools and screen readers are inconsistent
  3. Practical examples of where inconsistencies arise
    1. Static structure issues
    2. Dynamic content updates
  4. Why manual screen-reader testing is non-optional
  5. Pipeline comparison: A visual reference
  6. Common misconceptions
  7. Effective testing strategies
  8. Operational implications for teams
  9. Quick wins: getting started
  10. Conclusion: a framework for reliable accessibility
  11. Further reading
Abstract image on text on it: "

Why DevTools and screen readers are inconsistent

Digital accessibility depends on recognizing a fundamental reality: the information shown in DevTools is not the same information a screen reader announces. This is not a flaw in DevTools or in screen readers. It is the natural outcome of a multi-stage translation pipeline that transforms the DOM into something assistive technologies can consume.

Teams often overlook this pipeline, which leads to false confidence, unexpected behavior in testing, and accessibility regressions that escape into production.

This gap between what developers see and what users experience is not merely academic. It creates real-world problems: developers ship features they believe are accessible, QA teams pass issues they cannot see, and users encounter barriers that never appeared in testing.

Continue reading “Why DevTools and screen readers are inconsistent”
Caching Mongoose queries in a native MongoDB collectionArticle contains
  1. The problem with traditional caching
  2. A aifferent approach with MongoDB as cache storage
    1. Why MongoDB?
  3. Key features
    1. 1. Query caching
    2. 2. Automatic invalidation
    3. 3. Cross-collection invalidation
    4. 4. Size limit and periodic sweep
    5. 5. Connection-pool resilience
    6. 6. Multi-database support
  4. How it works: architecture
    1. Scalability benefits
  5. Quick start
  6. Comparison: Redis vs. MongoDB-native caching
  7. When to use this package
  8. Best practices
    1. 1. Start with high-impact queries
    2. 2. Set appropriate TTLs
    3. 3. Monitor cache size
    4. 4. Understand the coarse-grained invalidation
    5. 5. Test cache behavior under load
  9. Comparison with other solutions
  10. Final thoughts
Set of computers showing infrastructure for databases. Image by Suresh anchan from Pixabay.

Caching Mongoose queries in a native MongoDB collection

If you’re building a Node.js application with Mongoose, you’ve probably felt the pain of database performance at scale. The go-to solution? Add Redis. Set up a caching layer, wire it into your queries, and hope the invalidation logic doesn’t become a maintenance nightmare.

But what if we told you there’s a simpler way – one that uses the database you already have, requires zero additional infrastructure, and handles cache invalidation automatically?

Meet @sitelintpackages/mongoose-cache: a MongoDB-based caching solution for Mongoose queries with TTL and automatic invalidation support.

Continue reading “Caching Mongoose queries in a native MongoDB collection”
Getting your website ready for Google's new AI-powered searchArticle contains
  1. Is this still SEO? Do I need to learn a new trick?
  2. What actually matters for AI search
    1. 1. Create content that only you can create
    2. 2. Build a clear and accessible technical foundation
  3. What you can safely ignore: mythbusting AI search
  4. Looking ahead: is your website ready for a helpful robot?
  5. The bottom line: don’t chase hacks, chase helpfulness
  6. A practical tool to help you improve
Three letters "SEO" neon. Image by Dee from Pixabay.

Getting your website ready for Google’s new AI-powered search

The way people search is changing. More and more of us are turning to AI tools to help us find answers, discover products, and make decisions. Google is evolving to meet these new habits with features like AI Overviews and AI Mode, which summarize information directly on the search results page.

This shift isn’t a threat to your website – it’s a new opportunity. These AI features can help you connect with people who are more likely to click through, spend time reading your content, subscribe to a newsletter, or make a purchase. This guide translates Google’s official advice into plain language, helping everyone from bloggers to business owners understand how to succeed in this new landscape.

Continue reading “Getting your website ready for Google’s new AI-powered search”
Digital accessibility without an audit? Why "audit first" approach doesn't work.Article contains
  1. Introduction
  2. The myth: accessibility starts with an audit
  3. Reality: accessibility is a systemic problem
  4. Accessibility debt: do you really need to start with an audit?
    1. The thinking issue: let's fix everything at once
  5. What accessibility debt really means
    1. Where do you really need to start?
    2. Another metaphor
  6. Why the audit first model doesn't scale
    1. The scale of the problem
    2. The audit market
  7. What an audit actually does (and doesn't do)
    1. An audit
    2. But an audit does not:
  8. What I mean by "audit"
  9. When I say audit, I don't mean…
  10. How does an organisation know what to fix?
    1. Sources of knowledge about problems
  11. What to do instead of an audit (at the start)
  12. An audit - yes, but later
  13. Accessibility as a maturation process
  14. The most important shift
  15. When an audit is necessary
    1. Formal requirements and legal accountability
    2. Independent verification
    3. Key moments of change
    4. Complex or high-risk areas
  16. Summary
Minimalist illustration of a cluttered, inaccessible website interface highlighting issues like missing alt text, low contrast, unlabeled buttons, and no video captions - symbolizing why "audit first" fails in digital accessibility.

Digital accessibility without an audit? Why “audit first” approach doesn’t work.

Introduction

In discussions about digital accessibility, one phrase keeps coming up: Audit first.

Other phrases follow: an audit is essential, you can’t do without an audit. It sounds rational. After all, to fix something, you first need to know what’s wrong.

The problem is that in practice, the audit first, then fix approach usually does not lead to lasting accessibility improvement. What’s more, it very often reinforces the very mechanisms that cause barriers to appear in the first place.

Continue reading “Digital accessibility without an audit? Why “audit first” approach doesn’t work.”
CSS contrast-color() function, its possibilities and limitationsArticle contains
  1. What contrast-color() is and why it matters
  2. How the function works under the hood
  3. Syntax and basic usage
  4. Customizing contrast choices
  5. Practical use cases for real-world UI
    1. Buttons and interactive components
    2. User-selected themes
    3. Data visualizations
    4. Design systems
  6. Improving accessibility with automatic contrast
  7. Browser support and progressive enhancement
  8. Common pitfalls to avoid
    1. Assuming it enforces WCAG ratios
    2. Overriding the computed color
    3. Using too many candidate colors
    4. No support for gradients or images
    5. No support for APCA
    6. No transparent or currentColor support
      1. The transparent problem
      2. The currentColor problem
      3. Why CSS can't solve this natively
      4. What actually works
      5. Practical workarounds
      6. Future possibilities
  9. Conclusion
Abstract background and the following text on it: "CSS, contrast-color()"

CSS contrast-color() function, its possibilities and limitations

Color contrast has always been one of those deceptively simple problems. On the surface, it’s just light text on dark backgrounds or vice versa. In practice, it’s a constant balancing act between design intent, accessibility requirements, and dynamic UI states. We often ending up writing custom logic, maintaining color tokens, or relying on design system heuristics that don’t always hold up.

The new contrast-color() CSS function changes that dynamic. It gives the browser the responsibility of choosing an accessible foreground color based on the background in an automatically, predictably, and in line with modern color science.

Continue reading “CSS contrast-color() function, its possibilities and limitations”
The hidden SEO advantage with accessibility properties in JSON-LDArticle contains
  1. Introduction
  2. What are accessibility properties in JSON-LD?
  3. Core JSON-LD accessibility properties
    1. The speakable property
      1. How speakable works
      2. Implementation speakable in your WebPage schema node
    2. Choosing the right selectors
    3. Technical requirements for speakable
  4. Visual diagram that illustrates how accessibility JSON-LD properties act as a bridge between accessible code and search engine understanding
  5. What are the benefits of including accessibility-related data in a schema?
    1. Semantic clarity for search engines
    2. Preparation for Accessible Search
    3. Potential for enhanced visibility
    4. Strengthening E-E-A-T through technical integrity
    5. Synergy with WCAG compliance
    6. A warning on vanity metrics
  6. Testing your markup
  7. Conclusion
SEO inscription on three blocks and below it: Accessibility & JSON-LD

The hidden SEO advantage with accessibility properties in JSON-LD

While developers obsess over Core Web Vitals and keyword density, a powerful SEO signal hides in plain sight: accessibility metadata. By adding schema.org’s accessibility properties to your JSON-LD, you’re not just helping users with disabilities – you’re creating machine-readable proof of quality that search engines are already beginning to prioritize.

Continue reading “The hidden SEO advantage with accessibility properties in JSON-LD”
Removing Angular-specific data from HTMLArticle contains
  1. The utility method
    1. Example
  2. Why this matters
  3. Node.js and Jest limitations note
  4. Security note
  5. Closing thought
Fixing Chrome's "Cannot load extension with file or directory name _metadata" error on macOSArticle contains
  1. What is actually happening
  2. Quick solution
  3. Better Solution (recommended)
  4. Side note: the real _metadata folder
Google Chrome logo on abstract background. Image by Tyli Jura from Pixabay.

Fixing Chrome’s “Cannot load extension with file or directory name _metadata” error on macOS

Cannot load extension with file or directory name _metadata. Filenames starting with “_” are reserved for use by the system.

If you develop Chrome extensions on macOS you have probably seen this message the first time you zipped your Chrome extension folder and tried to reload or publish in Chrome Web Store the extension.

Continue reading “Fixing Chrome’s “Cannot load extension with file or directory name _metadata” error on macOS”
Replacing glob-all with fs.promises.glob in Node.jsArticle contains
  1. The glob-all way of using
  2. Replace glob-all with fs.promises.glob in Node.js at least 22.2
  3. Mapping old way to new way
  4. Quick conversion rule
  5. Error handling
  6. Benefits of using fs.promises.glob
  7. Example use case
  8. Conclusion
Node.js logo on the abstract background. Abstract background made by Gerd Altmann from Pixabay.

Replacing glob-all with fs.promises.glob in Node.js

As Node.js continues to get more and more native, built-in features, developers are constantly looking for ways to simplify their code and reduce dependencies on external packages. One such opportunity arises when replacing (or much better alternative to) the glob-all package with the built-in fs.promises.glob function, available in Node.js from version 22.0.0 behind the flag --experimental-glob and became un-flagged in v22.2.0.

Continue reading “Replacing glob-all with fs.promises.glob in Node.js”
Native built-in browser elements you can use today instead of ARIA or ROLE attributesArticle contains
  1. The first rule of ARIA
  2. Why move away from ARIA?
    1. Browser-engine privilege
    2. Less code, less maintenance
    3. Smaller payload, faster render
    4. Built-in resilience to future spec changes
    5. Mobile and voice-input compatibility
    6. Security and performance isolation
    7. Internationalisation for free
    8. Future-proofing for new input modalities
    9. Easier testing and audits
    10. Legal, procurement safety
  3. When ARIA is still justified
  4. Native HTML replacements for ARIA roles and attributes
  5. Conclusion
Text "Aria to semantic HTML" where "HTML" is on tiles.

Native built-in browser elements you can use today instead of ARIA or ROLE attributes

When building accessible web applications, developers have long relied on ARIA and role attributes to fill gaps in native HTML.

But today, many of those gaps are gone. Modern browsers support a wide range of semantic HTML elements and built-in behaviors that make ARIA redundant in most cases, often with better results and fewer bugs.

This shift towards native accessibility features means that developers can now create accessible web applications using built-in browser elements and attributes, rather than relying solely on ARIA and ROLE only.

We’ll explore the native built-in browser elements and attributes that you can use today to improve accessibility, and how they can replace or complement ARIA and ROLE attributes in your web development workflow. By leveraging these native features, you can simplify your code, improve maintainability, and create more accessible web applications for everyone.

Continue reading “Native built-in browser elements you can use today instead of ARIA or ROLE attributes”