← Back to Blog

Your first accessibility audit (Part 3 of 7)

Part 3 of a 7-part series on starting a career in accessibility

Grant Broome • (Co-founder, CEO) • 13 min read

Published

Updated

What your first accessibility audit should look like, what tools you should use and what it should contain.

Accessibility TestingVocation

I'll start with a confession: my first audit was dreadful. At best, it was thin. I could find most of the issues on my own, but I needed a lot of help with the rest. I was the only accessibility champion on my team, though I was lucky to have some smart, enthusiastic developers around me who backed me up. You've got it easier now. There are far more resources out there and a much bigger community you can ask for help. And you should ask.

You'll learn a huge amount on your first audit. The learning never really stops, but early on the curve is steep, and your first audit will probably feel dizzying and take longer than you expect. So give yourself some time and space, and take the pressure off where you can.

Ideally you won't do your first audits alone. You'll have a mentor with at least a few years' experience who checks your finished work before it goes anywhere.

Because the learning curve is so steep, I'd do your first few audits on practice sites. After that, try one for a real customer, either for free or in exchange for something like design or web development work. Treat it as a chance to learn how to deliver a report and support a client through it.

Before you start

Here's what you'll need before you begin.

Guidelines

We'll use WCAG 2.2 as our guide and stick to the Level A and AA criteria. AAA criteria can be useful, but in practice you'll rarely test against them. Read through them so you know what's there, and you might add the odd one to an audit now and then. Most organisations find full AA conformance hard enough already, so start with AA.

If you're new to accessibility, do at least a couple of practice audits so you can work through the criteria one by one. It's the best way to learn them.

Operating systems and tools

The WebAIM Screen Reader User Survey tells you a lot about the setups screen reader users actually have. Screen reader users aren't the only people you're testing for, but if you want a career in testing you need to understand their experience.

According to the survey, most screen reader users are on a Windows laptop running JAWS, NVDA or both, and fewer than 10% use a Mac. If you're a Mac user, the built-in screen reader, VoiceOver, is pretty good and will probably do for your first few audits. It's clunky compared to the Windows screen readers, though, and you'll need to use Safari for the best compatibility.

If you plan to make a career of this, I'd strongly recommend getting a decent Windows laptop and doing most of your testing on it. I know. Probably not what you wanted to hear. Sorry.

You should also get familiar with switch devices and voice control software such as Dragon NaturallySpeaking. These can be very expensive, so I wouldn't buy them straight away, but you do need a clear idea of how they work and the kinds of problems their users run into. For an introduction to how people with mobility impairments use this technology, watch Bill Miller's short video. Towards the end he browses websites using only his voice.

For switch access, I'd recommend Christopher Hills' videos. I use them in my training courses, and they help people understand how and why someone would use a switch.

You'll be emulating switch access to some degree throughout your testing, because you have to be able to get around a page without a mouse to test it fully. nomouse.org has some guidance to get you started.

Recording your results

This is the Labrador blog, so obviously I'm going to recommend Labrador. It cuts down the time you spend testing and writing reports. The guidance is built in and written in plain English, and it produces a professional-looking list of issues you can share straight with your clients. You get two full tests free every month, and it keeps your reports indefinitely. We put a lot of thought into making it easy to use. Go and have a look.

If you're not using Labrador, you could log issues in bug-tracking software such as Jira. You'll still need a proof-of-work document, though, both for your own peace of mind and to show that you've checked every WCAG 2.2 AA criterion. Traditionally that's a spreadsheet: each page or component in your sample gets a column, each WCAG criterion gets a row, and you check every page against every criterion and note what you find. Spreadsheets have serious limits. Adding images as evidence is a real PITA, and versioning gets messy. Save yourself from discovering the rest by signing up for Labrador.

However you record things, treat repeated content as its own component so you don't log the same issue on every page. A site's header and footer will probably appear on every page in your sample (more on the sample later), so you only need to record their results once. In Labrador you create a separate component for them; in a spreadsheet you give each repeated component its own column.

Component, page or blended testing

Another approach is to identify every component in your sample and test each one individually. Most websites reuse the same components, so if you've tested one on one page, you'll usually get the same results wherever else it appears. Headers and footers should almost always be tested this way. Forms are better tested page by page, because forms on different pages can differ a lot.

So a blended approach usually works best. List the pages in your sample, then list the common components within them that only need testing once: header, footer, video player, carousel, side menu, and anything else that appears unchanged across several pages. Anything that varies, such as articles, product pages, apps and games, you test and record at page level. The point is to avoid logging the same issues over and over. Repetition is as tedious to read as it is to write, so do everyone a favour and keep it to a minimum.

Screenshots and video

A picture is worth a thousand words, or so they say, and a screenshot helps designers and developers find and understand an issue quickly. Include one with almost every issue you raise, and use markup tools to circle or box the problem so it's easy to spot. Where a still image won't show the problem properly, record a video.

Sample size

Websites and apps can run to hundreds or thousands of pages. Nobody tests them all; it would take too long and cost too much, and each extra page tells you less than the one before.

What you want is a representative sample. Look through the site for pages with distinct content: forms, video, applications, games and the different page templates. Meet your client to help pick them, as they'll know the site far better than you do. As a very rough guide, aim for 10–20 pages.

Some companies claim to test far more pages than this, but they're running automated scans across most of them, with full manual testing on only a few. It's a bit sneaky, and agencies should be more open about it. You might want to run an automated scan across the wider site too, as long as you tell your clients clearly what was scanned and what was manually tested. I won't recommend a particular scanning tool here, but a quick search will turn up plenty.

Agree the scope with your client before you start.

What each issue should contain

When I started, almost nobody wanted to spend money on accessibility. Projects were underfunded and rushed, and my early audits were very light: a screenshot and maybe a paragraph of text, with a pass or fail attached.

Your reports need much more detail. Each issue should include:

Most of those are self-explanatory, but severity and priority are subjective. Use a severity scale something like this: Advisory, Minor, Moderate, Serious, Critical. Keep Advisory for things that aren't WCAG AA failures but still affect the user experience or go against best practice. Say a link has the visible text "Go to basket" and a title attribute that also says "Go to basket". Some screen readers will read that out twice in some situations. It's irritating for screen reader users and worth calling out, but it isn't a WCAG AA failure. At least, I don't think it is.

Which brings me to another point: accessibility professionals disagree about whether things pass or fail, and how severe they are. That's fine. What counts is that you're clear about your reasoning.

Bear in mind that your decision can hold up a product release or lead to costly remediation. Never inflate an issue's severity to make it land harder, and never play one down either. Judge severity by the impact on the user. How easy or hard it is to fix has nothing to do with it.

Priority can usually follow severity, but sometimes you'll want to raise it. An issue with low impact when someone hits it once can have a much bigger impact if they hit it constantly. Or a low-severity issue might be so quick to fix that it's worth doing straight away for an immediate improvement. In cases like these, set the priority separately.

Tone

My first audits weren't particularly friendly. I'm not sure why. I probably wanted to make an impression, and the one I made was a poor one.

Finding issues is only part of your job. You also need to help your client's teams understand what the issues are and how they affect users, and then help them fix them. You're an ambassador for accessibility. Be helpful and friendly, and give your client as much support as they need to resolve what you've found. People should come away glad they chose to work with you, and feeling that they're making the world a bit better.

The fix: how far do you go?

That depends a lot on how much you know. I had some idea of HTML when I started in accessibility, and it's fairly easy to pick up, at least well enough to understand what the code is doing. CSS and JavaScript are harder, but you'll learn what you need over time.

If you have no coding experience, do at least a beginner's HTML course. It's very hard to recommend a fix when you can't read what's causing the problem. AI can help, but it makes mistakes, and if you can't spot them you'll end up recommending fixes you don't understand and that may be wrong.

If you understand little or none of the code, point people in the right direction instead. If a form field has no label, for example, link to a resource that shows how to add one, such as MDN's page on the <label> element and its for attribute. Don't bluff, and describe the fix in plain language.

You'll get better at this with time.

The executive summary nobody reads (except everybody does)

It goes at the start of the document and runs to about half a page, but write it last, once you have all your findings. Include:

Leave out jargon and WCAG numbers, and if you need a term like "screen reader", explain it. This is the part the person with the budget will read.

The delivery

Never hand over an audit without a delivery meeting. I call it a playback.

The playback is your chance to talk the client through your findings, show them what the issues mean for users and help the team doing the fixing to understand them properly. It's also a chance to start building a relationship with that team, and in the long run that relationship counts for more than the report.

Don't read the report out to them. Either they've read it already or they haven't, and reading it word for word is a poor use of everyone's hour. Walk through the most important findings. Demonstrate the screen reader experience where you can, and show the keyboard problems. Make it visceral. Findings hit much harder when people watch them happen than when they read about them in a PDF on a Friday afternoon.

You may get some pushback. There's the reasonable kind ("we use a third-party widget and we can't change it"), the defensive kind ("it works fine when I test it") and the occasional flat denial ("we ran an automated scan and scored 95%"). All of it is normal. Don't argue: acknowledge it, explain your reasoning and move on. Winning the meeting isn't the goal; getting the right things fixed is.

And if you've got a finding wrong, say so. It happens, especially when you're starting out, and even after all these years I'm not immune. Owning a mistake on the spot earns you far more credibility than digging in.

The day after

A common mistake new testers make is treating the audit as the end of the engagement. Send the PDF, raise the invoice, move on.

What the client is paying for is a better website, and the audit is one step towards it. Nobody fixes accessibility issues in a vacuum. Your client will have questions. They'll find things in your report they're not sure how to read. They'll wonder whether their proposed fix actually solves the problem, and they'll want some direction and a second pair of eyes before they push anything to production.

So follow up. A short check-in two to four weeks later: "How's the remediation going? Anything I can clarify? Anything you'd like a second opinion on?" Sometimes it leads to more work and sometimes it doesn't. Either way it builds trust, and it makes you the obvious person to call next time.

The clients I'm still working with twenty years on are the ones I followed up with after the first audit. Report quality had much less to do with it.

A bit of encouragement: you'll get better

Your first audit will be worse than your second. Your second will be worse than your tenth. Your tenth might still make you cringe in five years' time. That's the job, and you'll have to make peace with it.

What nobody tells you is that most of your improvement comes from somewhere other than WCAG knowledge. You'll pick up most of the WCAG side in your first year. After that, you get better at everything around it: scoping properly, and pacing yourself so you're not running on fumes by page 180 of a 200-page report. Getting the tone right. Knowing what to leave out. Disagreeing with a developer without making it personal. Saying "I don't know" without losing credibility.

You won't find any of that in the guidelines. It's what the work is made of.

Where next

Part 4 is about what comes after you've delivered a few decent audits: building a reputation, finding your way into a network of people doing this work, deciding what you want to be known for, and the difference between being visible and being shouty.

See you there.