What is the most common QR code mistake?

Printing a code that's physically too small for the intended scan distance. Most failures I see in the wild trace back to a code that looked fine on a 27-inch monitor but ended up at 1.5 cm on a printed flyer. The fix is a physical size proportional to the maximum scan distance — roughly one centimetre of code per ten centimetres of distance, with a minimum around 2 cm even for tabletop reads.

Why do QR codes stop working after a campaign launches?

Almost always because the destination URL changed and the code was static. Static QR codes hard-encode the URL into the matrix; once printed, the destination is fixed forever. If the link needs to change — staging URL accidentally shipped to print, marketing reassigned the slug, the page was retired — a static code becomes dead the moment the URL moves. Dynamic codes route through a redirect, which is what makes that editable.

Can I put my logo in the centre of a QR code?

Yes, but only at error-correction level Q or H, and only at roughly 25 to 30 percent of the code's area. Anything bigger eats more modules than the Reed–Solomon redundancy can recover, and the code starts failing intermittently — which is worse than failing always, because nobody catches it in QA.

Should I use a colored QR code?

Coloured codes work, but the contrast ratio between modules and background needs to stay above roughly 4.5:1, with the modules darker than the background. Inverted codes (light on dark) work on most modern phones but still fail on a meaningful percentage of older Android scanners. Test on at least three different devices before committing to print.

Why does my QR code work in design software but not in real life?

The design preview is rendered at 100 percent zoom on a high-DPI screen with perfect lighting. Real scans happen at variable distances, on cellular signal, in restaurant lighting, with reflections from glossy paper, and through the camera of whatever phone the user happens to own. Always test from a printed proof on a real phone, not a Sketch artboard.

The 12 QR Code Mistakes I See Most Often (and How to Avoid Them)

I’ve reviewed enough QR code campaigns at this point — restaurants, packaging, conferences, healthcare intake — to notice the same handful of mistakes showing up over and over, across teams that should know better. None of them are exotic. They’re the boring kind of failure: small enough to slip past a designer’s eye, big enough to cost a campaign once a print run is in the wild.

This post catalogues the twelve I see most often. Each one comes with how it shows up in production, why it’s hard to catch, and the cheapest fix that actually works. If you ship printed codes, working through this list before your next press file is the most leverage you’ll get for an hour of effort.

Key takeaways

Roughly half of QR scan failures trace to one cause: the code is physically too small for the intended scan distance.
Low contrast (anything below ~4.5:1 modules-vs-background) is the second most common failure; pastel and inverted codes both push this limit.
A four-module quiet zone is non-negotiable; tight design frames are the most common reliability mistake.
Logos larger than ~25% of code area exceed Reed–Solomon recovery and produce intermittent failures — worse than consistent ones, because nobody catches them in QA.
Test a printed proof on at least three real phones (one older Android) before any production run; the design-tool preview is not a substitute.

Print size dominates the failure mix by a wide margin. Fix sizing first; the rest of the list is meaningfully cheaper to address once the code is large enough to scan.

1. The code is physically too small

This is the most common production failure I see, full stop. A QR code looks fine in a layout file, scans fine on the designer’s phone from 15 cm away, and then ends up at 1.5 cm wide on a flyer that someone is supposed to scan from arm’s length.

The rule of thumb worth memorising: a QR code needs roughly 1 cm of physical width for every 10 cm of intended scan distance, with a hard floor around 2 cm even for tabletop reads. A poster meant to be scanned from across a room (3-5 metres away) needs a code in the 30-50 cm range. A table tent? 2-3 cm. A business card? 1.5-2 cm minimum, and only because the user is holding it.

There’s a deeper guide on physical sizing in the QR code size and print guidelines post. Read it before sizing any code that’s going to print.

2. The contrast ratio is too soft

Modern phone cameras are good but not magical. They need a clean step-function between the dark modules and the lighter background, and the moment that step softens, scan rates fall off a cliff. Brand teams keep wanting to use grey-on-grey or a dark-blue-on-charcoal combination because it matches the visual identity. It will scan in the studio. It will not scan reliably in a dim room or at a glancing angle.

The minimum contrast ratio that holds up in the wild is roughly 4.5:1, modules darker than background. Anything below that is rolling dice on every scan. There’s a separate question — covered in the colored QR code post on /learn — about which colour combinations are safe and which are accident-prone.

Inverted codes (light modules on a dark background) are the spicier version of this same problem. They work on most modern iPhones and recent Android devices. They still fail on a meaningful share of older Android scanners that assume modules-dark-on-light. Don’t ship inverted codes unless you’ve tested them on three or four real phones across both platforms.

3. The quiet zone is missing or too thin

The “quiet zone” is the unprinted margin around a QR code. The ISO/IEC 18004 standard requires it to be at least four modules wide on every side, and that’s not aesthetic guidance — it’s the area scanners use to lock onto the finder patterns. Without enough quiet zone, a scanner can’t tell where the code ends and the rest of the world begins.

What I see: designers crop the QR code right up to the edge of a card or sticker because the layout feels tight. The code scans on a clean white sheet but starts failing the moment it’s surrounded by other ink. The fix is mechanical — leave a four-module margin minimum, and treat that margin as part of the code, not as wasted space.

4. The destination URL hard-codes a staging or campaign URL that will change

This is the failure that hurts the most because nobody catches it until launch. Marketing approves a campaign with https://staging.brand.com/spring-promo. The agency generates a static QR code from that URL. The flyers print. The campaign goes live. Now every scan goes to a 404.

The fix is structural. Either:

Use a stable, production-grade URL on the printed asset (not staging, not an environment that’s temporary), and freeze the slug for the lifetime of the campaign.
Use a dynamic redirect so the printed code is https://yourdomain.com/r/spring and the destination can be repointed without a reprint.

The trade-off between those two approaches is the entire subject of static vs dynamic QR codes. The relevant point here: if there’s any chance the URL will change post-launch, the cost of a redirect service is trivial compared to the cost of a reprint.

5. The redirect chain is two or three hops deep

When teams do use dynamic codes, the failure mode flips. Now the code points at bit.ly/abc, which 301s to tracker.brand.com/x123, which 302s to brand.com/landing?utm_source=qr, which then 301s again to brand.com/landing/. Each hop costs a network round-trip, and on weak cellular each one is a chance to time out.

I’ve seen restaurant menu QR codes take 6-8 seconds to load on a busy Friday night because the redirect chain was four hops deep over flaky in-restaurant Wi-Fi. The user closes the page before the menu appears. From the operator’s view: scan rates are fine, conversion rates are mysteriously terrible.

The fix: keep your redirect chain to at most one hop. The code should hit your tracker, the tracker should 301 directly to the destination, end of story. Audit periodically with a tool like curl -ILs <url> to count the hops.

6. The logo is too big for the chosen error-correction level

Adding a logo to the centre of a QR is fine — within limits. The QR code’s error-correction level determines how much of the matrix can be obscured before scans start failing. Level L tolerates ~7%, M ~15%, Q ~25%, H ~30%.

What goes wrong: the brand insists on a big logo, the designer cranks the logo size up to 35-40% of the code area, and the code is generated at level M because nobody told them to switch. Now the code scans intermittently — sometimes on a clean phone, sometimes not, depending on how aggressively the scanner re-tries. That intermittent behaviour is the worst possible failure mode because it survives QA and only breaks for real users.

The rule: logo at most 25-30% of code area, at error-correction level Q or H, and always re-tested after the logo is composited in. The full pattern is documented in the QR code with logo guide.

7. The QR is rasterised at low resolution before print

Designers download a QR code as a 300×300 pixel PNG, drop it into InDesign, and scale it up to 80 mm wide on the press file. The press RIP interpolates the pixels and the module edges blur. At 300 DPI the modules are no longer crisp — they have soft, fuzzy edges that look fine on screen but confuse some phone cameras.

Use SVG instead of PNG for any code that’s going to print. SVG renders perfectly at any size and the file is usually smaller. If your printer requires raster, generate the PNG at the final printed size at 600 DPI minimum, never at a smaller size and then scaled up.

8. The proof is checked on the designer’s phone instead of a printed sample

This is methodology, not design. The designer scans the code in their layout software on their iPhone 15 Pro at 30 cm in perfect light, and signs off. They have not tested:

An older Android device.
A weak cellular connection.
Glossy stock that creates glare.
A scan distance closer to what the actual user will attempt.
A printed proof — they tested the on-screen layout.

Add a step to the workflow: print a one-off proof on the actual stock, hand it to three colleagues with different phones, ask them to scan from the distance the customer will scan from. Most failures get caught right there.

There’s a longer pre-press checklist in the print-ready QR code checklist that codifies this exact workflow.

9. The destination page isn’t mobile-optimised

The QR scans fine, the redirect resolves, and now the user lands on a page that requires horizontal scrolling, takes 8 seconds to render the hero image, or pops a cookie banner that covers the call to action. The QR code did its job; the destination page killed the conversion.

Treat the QR-scan landing page like any other mobile-first page:

Page weight under 500 KB total, ideally.
Above-the-fold action visible without scrolling.
No interstitials, no auto-play video, no full-screen modal on first paint.
Tested on a throttled “Slow 3G” Lighthouse profile.

If you can’t deliver that, the QR code is just a fancier way to lose customers.

10. Tracking parameters are missing or inconsistent

Marketing teams push for analytics on every campaign, then skip the actual tracking parameters when generating the QR. The code goes to https://brand.com/landing instead of https://brand.com/landing?utm_source=poster&utm_medium=qr&utm_campaign=spring2026, and now there’s no way to attribute scans back to the placement.

Worse: each placement uses a slightly different parameter scheme. The cinema poster has utm_source=cinema while the bus shelter has utm_source=outdoor_bus. By the time analytics tries to roll up the campaign, the data is unjoinable.

The fix is operational: define a UTM scheme before any code is generated, document it, and stick to it. There’s a longer take on this in how to track QR code scans.

11. The code is positioned where nobody can scan it

Physical placement matters as much as the code itself. I’ve seen QR codes printed on:

The inside fold of a brochure that opens vertically (you have to hold the brochure overhead).
The back of a chair, where the customer would have to stand up and turn around.
A wall behind a counter, four metres away, at a 1.5 cm size.
A glossy magazine page facing a window, where reflections wash out the code.

A scannable code is one a customer can physically reach with their phone, in good light, without contorting themselves. Walk the placement before you ship.

12. There’s no analogue fallback for users who can’t or won’t scan

A QR code is not a universal access mechanism. Some users can’t scan because of the device they own, the lighting they’re in, the connectivity they have, or the friction of opening their camera. Designing as if 100% of users will scan is a planning error.

Always pair a QR code with:

A short URL printed in human-readable text alongside it (brand.com/menu).
Optionally a vanity number or NFC tap for users who prefer those routes.

This is a small accessibility/UX investment that prevents your QR-driven campaign from accidentally excluding a meaningful slice of customers.

What to do next

If you ship printed QR codes, run this twelve-item checklist on your next campaign before the press file goes out. Most failures get caught at items 1-5 alone, but every item on the list has cost someone a campaign at some point.

If you’ve launched a code that’s now failing in production, jump to the diagnostic walkthrough in why some QR codes don’t scan — it’s the field-tested order I run through when triaging a failing code in the wild.

For a forward-looking view on how the QR landscape is shifting (and which mistakes will matter more in the next year or two), see QR code trends worth watching in 2026 and the take on AI and QR codes in 2026. And if you’re putting a QR code on professional collateral specifically, the LinkedIn / professional networking QR post covers the placement and format choices that matter for that surface.

Sources

ISO/IEC 18004:2015 — The international QR code standard; specifies the four-module quiet zone and L/M/Q/H error-correction tolerances referenced in mistakes #3 and #6.
Denso Wave — QR Code Applications — Reference from the QR inventor for Reed-Solomon error correction, module-density tables, and the conventional code structure that the rasterisation and logo-coverage failure modes deviate from.
Wikipedia — QR code — Background on scanner behaviour, contrast handling, and the practical sizing constraints behind the printed-size failure mode (mistake #1).