What we charge, and what changes the number

Every price here is a starting point. It's the floor for a piece of work with a shape we recognize, and it holds when the work has that shape.

So the first thing that happens is a call. Thirty minutes, usually less. We ask what you're trying to get through, what deadline is attached to it, and what you already know about your own system. Then we ask to look at the actual thing, because a quote written off a description of a site is a guess wearing a decimal point.

After that you get a written scope. It names the templates, the flows, the browsers, and the assistive technology. It names the deliverable and the date. It also names what we're not looking at, which is the part most proposals leave out and the part that causes every argument later. An audit that doesn't say what it excluded is claiming more than it tested.

You see the final number before anything starts. Not a range that firms up later. Not an hourly meter you watch with your stomach in a knot. A number, in writing, that we've both agreed to.

And if the work turns out bigger than what we quoted, you hear about it before we do the extra hours. That's a conversation, not a surprise line on an invoice.

Four things, mostly, and none of them is page count.

How many distinct patterns you have. A hundred pages assembled from one component library audits faster than eight pages that each invented their own navigation, form, and dropdown. We scope by counting unique templates, components, and end-to-end flows, because WCAG conformance is evaluated per page and per process. When a checkout has five steps and step four fails, the whole flow fails, so we test the flow and not a sample of URLs.

How much of it is custom. Native HTML elements behave. A dropdown built out of divs with a pile of ARIA on top has to be tested keystroke by keystroke in three different screen readers, and it usually fails differently in each one. Custom widgets are where the hours go.

What the flow is worth. A marketing page and a benefits enrollment wizard aren't the same test. Anything that takes money, takes an application, or takes a legally consequential action gets tested harder. That's usually where you wanted the hours anyway.

Whether anyone's been here before. A team with a design system, some existing accessibility work, and a person who owns it costs less to audit than a codebase nobody has ever looked at this way. That isn't a reward for good behavior. There's just less to find and less to explain.

Frameworks matter less than people expect. React, Rails, WordPress, Vue, or something built in 2014 that still runs fine, the barriers are remarkably consistent across all of them. What changes is how cheaply a fix can be applied once and land everywhere.

Included in every audit. Automated scans cleared first, so your money goes to the part that needs a person. Manual keyboard testing. Screen reader testing with NVDA and JAWS on Windows and VoiceOver on macOS and iOS. A written report organized by cause instead of by URL, with each finding mapped to a success criterion and a specific fix. A scope statement saying what we tested and what we didn't. And one verification retest after your fixes land, showing what closed and what regressed.

Also included, and people expect to pay extra for it. We write down what's already working. If your focus styles are correct on purpose and your form errors are announced properly, you need that on paper before a redesign quietly throws it away.

Not included unless we scope it in. Native mobile apps, which are their own engagement with their own tooling and their own failure modes. PDFs and other documents. Third-party embeds you don't control, which we'll flag and describe but can't fix inside someone else's script. Content training for your marketing team. Legal advice, which we aren't qualified to give and won't pretend to.

Level AA is the target. That's what Section 508, EN 301 549, the ADA Title II rule for public entities, and procurement questionnaires all point at. Level AAA contains criteria the W3C itself says can't be satisfied across all content, so we'll target selected AAA criteria where they make sense for a specific product, and we won't sell you a whole site at that level. Anybody offering that is quoting a level the spec says isn't achievable as a general policy.

A retainer is a block of hours with your name on it, spent on purpose.

Every month opens with a short list. You say what matters, we say what it costs in hours, and we agree on the order. That takes about fifteen minutes, and it's the whole difference between a retainer that ships things and one that dissolves into Slack threads and good intentions.

Hours are capped and named up front. Twenty, forty, or eighty. When we're heading toward the cap, you hear about it while there's still time to choose, and going over is agreed in writing before the work happens. Never after.

Unused hours don't roll over, and we'd rather say that here than bury it in a contract. Rollover sounds generous and works badly. It becomes a balance nobody spends, then a request for forty banked hours in a week that doesn't have forty hours in it. A cap you actually use is worth more than a balance you never will. If you're consistently under yours, drop a tier. We'll bring it up before you do.

Everything is month to month with 30 days notice. No annual term, no two-year commitment, no auto-renewing agreement you have to fight your way out of. If the work's worth keeping, you'll keep it. That's the entire retention strategy.

One thing about monitoring, because this is where a lot of vendors overpromise. Scanning on the care plan is automated and the alerting runs continuously. Humans read those alerts and respond during business hours. We won't tell you somebody's awake at three in the morning watching your dashboard, because nobody is, and a shop that promises otherwise is writing a check its staffing can't cash. If you need paged after-hours coverage, that's a separate on-call agreement with its own scope and its own price.

You'll see monthly plans advertised elsewhere with unlimited sites and an open request queue. We don't sell that, and the reason is arithmetic.

An uncapped offer gets priced for the average customer and delivered to whoever shouts loudest. Two things follow. Either the quiet clients quietly subsidize the loud ones, or the vendor starts rationing without telling anyone, the queue gets long, and the answers get vague. You've probably been on the receiving end of the second one.

A cap is a promise you can check. Eight hours a month across four named sites either happened or it didn't, and you can tell which by looking at what got done. An open-ended promise is a feeling, and you can't audit a feeling.

So the sites get named. The hours get counted. Adding a site changes the number, and you'll know the new number before you add it. That's less exciting on a sales page and considerably better to live with in month seven.

We test against a published standard and write down what we found. That's the product. It's worth a great deal and it isn't everything, so here's the boundary in plain words instead of buried in a footer.

We document conformance against a published standard. We don't guarantee legal outcomes and we don't indemnify legal risk. Nobody honest will tell you an audit makes you immune to a complaint. What you get is a dated record of real testing, a prioritized remediation plan, and evidence of work in progress. If a demand letter arrives, that record is a materially stronger position than a script tag bought in a panic. It still isn't a shield, and any vendor selling it as one is selling something they can't deliver.

On search and revenue. We do technical SEO work, and we'll show you measurable Core Web Vitals before and after, along with the crawl and markup problems we fixed to get there. We won't promise rankings, traffic, revenue, or any business result. Nobody controls Google's index, and a vendor who claims they do is either guessing or hoping you won't check.

On uptime and stability. We describe practices, not numbers. Reproducible builds. A pipeline that runs the test suite on every change. A rollback that takes one step and no improvisation. Error tracking wired to somewhere a human actually reads. If you need an uptime figure you can hold us to, that belongs in a contract with consequences attached, and we'll negotiate one deliberately instead of implying one on a marketing page.

On what accessibility work is for. Fewer barriers for the people actually using your product, and documented conformance you can hand to a buyer without flinching. That's the honest description of the value, and it's a good one. It just isn't a legal instrument.

And on scope. Changes get agreed in writing before the work happens, every time. That rule protects you more than it protects us, which is why it's on the pricing page.

Three comparisons come up on almost every call, so here they are with the tradeoffs pointed in both directions.

Against a full-time hire. A senior engineer costs salary plus payroll taxes plus benefits plus equipment plus whatever recruiting took, and the loaded number lands well above the salary figure you're picturing. Hiring also takes months to do and months more to pay off. A retainer starts in a week or two and ends with 30 days notice. What a hire gives you that we don't is somebody living inside your business every day, accumulating context nobody wrote down. That's real, and it's worth paying for once you can keep that person busy. We're for teams that don't need a full-time hire yet, or that can't justify three specialists when what they need is a slice of each.

Against an agency. Agencies staff in layers. An account manager, a project manager, and then whoever's free. You can end up paying senior rates for the coordination and getting the availability. A small shop trades the other way. Less surge capacity when you need six engineers next Tuesday. But the person who scoped your work is the person doing your work, and nothing gets lost being relayed twice.

Against a cheap audit. There are $300 accessibility reports out there. What you get is a scanner run with a cover page, which catches a minority of real barriers and misses the ones that stop people worst. Run axe or Lighthouse against your own site first. It's free, it takes a minute, and it'll find genuine problems. Then decide whether you want to pay somebody for the part a script can't do, which is the part that decides whether a person can finish checkout.

A bad fit costs you more than a deposit, so here are the honest disqualifiers.

If you want a certificate saying you're compliant and nothing else, we're not it. No such certificate exists, and the shops printing one are selling reassurance with a border around it.

If somebody on your team has already told a buyer that everything Supports, we can't sign that VPAT. We'll fill in the true one and help you close the gap, and that's a different conversation with your customer than the one you were hoping for.

If you need human coverage around the clock as part of the base price, we don't offer it and we won't imply we do. That's a separate on-call agreement or a different vendor.

If your budget is genuinely under a thousand dollars, spend it on running the free scanners, fixing your contrast, and making your site work with a keyboard. That's real progress, it's the cheapest accessibility work there is, and you don't need us for it. Come back when the procurement questionnaire lands.

If you want someone to work around your engineers instead of with them, we're the wrong shop. Your team sees every finding before leadership does, and our pull requests go through your review process where your engineers can reject them.

And if what you need is a legal opinion, hire a lawyer. We're engineers. We'll happily talk to yours.

Email hello@whyuascii.com with whatever is forcing the timeline. A demand letter, a procurement questionnaire, a VPAT request with a date attached, a release that keeps breaking, or a redesign you'd like to get right the first time.

Tell us roughly how big the surface is. How many sites, whether they share a framework, and whether anybody has looked at accessibility before. That's enough to put a range on it during the call.

Then a short call, then a written scope with a fixed number and a delivery date. You approve the scope, we start. Nothing gets worked before that, and nothing outside it gets worked without a written change.

If the answer turns out to be that you should do most of this in-house and only call us for the hard parts, we'll tell you that. It happens more often than you'd expect, and it's a perfectly good outcome for everyone.