<!-- meta: How QR codes work: error correction levels, static vs dynamic codes, why printed codes stop working, and how to test a code before you print it. -->
<!-- slug: how-qr-codes-work-why-they-stop-working -->
The square on your table is not a picture of a link. It is a file cabinet, and sometimes someone else owns the key.
A restaurant owner named Dana printed 400 table tents in March. Each one carried a QR code that opened her menu, created in twenty minutes with a free QR code generator and no thought about what would happen next. By July, half of them were dead. Customers were tapping their phones against the laminated card, squinting, and then ordering from a beat-up paper menu the server kept in her apron.
Dana did what most people do: she blamed the printer. Then she blamed her phone. Then she called the company that made the menu app, and got a support ticket number and a promise.
The real answer was less dramatic. Her code was a dynamic QR code, which means the black-and-white square did not contain her menu address at all. It contained a short redirect address owned by her menu vendor. When Dana downgraded her plan in June to save forty dollars a month, the redirect stopped resolving. The ink on the table tents was perfect. The code was perfect. The link behind it was gone.
This is the most common QR code failure in the world, and it is invisible: nothing about the printed square changes when it dies. To understand why, you need to know what is inside those little black boxes.
The short answer
A QR code is a two-dimensional barcode that stores data directly in a grid of black and white modules, plus error-correction data that lets a scanner rebuild missing pieces. There are two kinds: static codes, which contain the destination data itself and cannot expire, and dynamic codes, which contain a short link that redirects through a vendor's server. Static codes survive forever because there is nothing left to shut off. Dynamic codes survive exactly as long as someone keeps paying for the redirect. Most real-world failures come down to that distinction, plus a handful of printing mistakes: too small, too low-contrast, or missing the blank margin around the edges.
What is actually inside a QR code
Every QR code is a grid of modules read as binary. A scanner reads rows and columns the way a grocery scanner reads a barcode, but in two dimensions at once, which is why a QR code holds far more data.
Here is the part almost nobody knows: the data is not stored the way you would type it. It gets encoded, then interleaved, then mixed with error-correction bits, then arranged in a specific pattern. The three big squares in the corners are finder patterns that tell the camera where the code is and how it is rotated. A smaller alignment square helps correct for distortion when a phone photographs a code at an angle or on a curved surface.
The practical takeaway for a business owner is this: a QR code is not an image of a URL. It is a container. Change what is in the container and the printed square must change too. That is the entire static-versus-dynamic story in one sentence.
Error correction: why a logo in the middle still scans
QR codes carry redundant data so they can still be read when part of the surface is damaged, dirty, or covered. There are four error correction levels, and the recovery capacity is roughly standard across implementations:
| Level | Recovery capacity (approx.) | Typical use |
|---|---|---|
| L (Low) | ~7% | Clean digital displays, large high-contrast print |
| M (Medium) | ~15% | Default for most general-purpose codes |
| Q (Quartile) | ~25% | Codes with a logo, industrial or outdoor use |
| H (High) | ~30% | Heavy logo coverage, harsh conditions, damaged surfaces |
If you have seen a code with a logo punched out of the middle, this is why it still scans. At level H, roughly 30 percent of the code can be lost and mathematically reconstructed, so a logo covering 15 to 20 percent of the area fits comfortably.
The catch is the one almost every guide skips.
More error correction is not automatically better
To recover 30 percent of the data, you must store 30 percent more data, and those extra modules need physical space. An H-level code is therefore denser than an L-level code holding the same URL. Denser means smaller modules at a given print size, so the camera must resolve finer detail, and the code has to be printed larger to stay scannable from the same distance.
A code that scans perfectly at 2 centimeters with level L might need 3 centimeters at level H. On a business card, that difference can be the difference between working and failing. On a poster, it is irrelevant.
The rule of thumb: use the lowest level that survives your logo and your environment, then print bigger than the minimum. Maxing out error correction while shrinking the print creates codes that look robust and scan terribly.
Static vs dynamic: the distinction that decides whether your code dies
This is the part worth reading twice.
A static QR code contains the destination data inside the code itself. A URL, a phone number, a block of text, a WiFi password. The code is the data. There is no server in the middle, no account, no subscription. You can print it, laminate it, bury it in concrete, and it will still work in ten years because the phone is decoding the content directly from the ink. If your website changes, the old code breaks, and you have to print new ones. That is the tradeoff, and it is an honest one.
A dynamic QR code contains a short redirect URL, usually something like a vendor domain with a code suffix. When a phone scans it, it contacts the vendor's server, which looks up where that short code should send the visitor, and then forwards them. This is why dynamic codes can be edited after printing: the vendor changes the destination on their end, and your laminated table tent magically points somewhere new. It is also why dynamic codes expire. The redirect lives in a database that costs money to run. Stop paying, and the database entry goes away, and your printed code becomes a decorative square.
Neither is universally better. A static code is right when the destination will not change and you want permanence. A dynamic code is right when you need to change the destination later, or need scan analytics, and you accept that you are renting the redirect. What you must never do is assume a dynamic code is permanent.
The URL length problem (and why short links scan better)
Here is a detail that explains a lot of mysterious failures.
Longer data means more modules. More modules means a denser grid. A denser grid at a fixed print size means smaller modules, which the camera has to resolve at a greater distance. So the same physical sticker can be easy to scan with a short URL and nearly impossible with a long one.
Consider a typical long tracking URL:
https://www.example-restaurant.com/menu/2026/spring/specials?utm_source=table-tent&utm_medium=print&utm_campaign=spring-menuThat is 131 characters. Now the same destination through a short link:
https://ex.co/sp26That is 18 characters. The short version produces a dramatically sparser grid at the same print size. In poor light, at a distance, on a smudged surface, it wins every time. This is not a marketing trick; it is physics, and shorter input is the cheapest fix available.
The same logic explains why a WiFi QR code with a long password and a verbose network name can be finicky, and why a vCard with a full name, title, phone, email, website, and physical address produces a surprisingly dense code. Every character costs modules. A vCard can easily push past 200 characters, and at business-card print sizes that gets tight fast. If your vCard code fails on older phones, trim fields before you blame the phone.
Why codes fail in the real world: quiet zone, contrast, and size
Most "the QR code doesn't work" complaints have nothing to do with the data and everything to do with printing.
The quiet zone is the blank margin around the code. The specification calls for a margin of about four modules on every side. Without that breathing room, the scanner cannot reliably tell where the code starts and the background begins. Designers crop it constantly to make the code look tidier, and that single decision causes an enormous share of failures. If your code sits flush against a colored border, add margin back.
Contrast matters more than color choice. Dark modules on a light background is the reliable pattern. Inverted codes, light modules on dark background, work on some scanners and fail on others. Low-contrast pairings like dark gray on light gray, or brand colors with similar luminance, are a coin flip. If the brand palette demands a colored code, keep the dark modules genuinely dark and the background genuinely light.
Minimum print size is the third silent killer. The safe floor is roughly 2 by 2 centimeters, about 0.8 inches, for a short URL scanned from close range. Longer data needs more. Codes on a poster viewed from three meters need to be considerably larger. A useful rule: the code should be at least one tenth of the expected scanning distance. If people scan from two meters away, the code should be at least twenty centimeters across.
Glossy lamination, curved surfaces, plastic sleeves, sunlight, and textured paper where the ink bleeds into the fibers all make these problems worse.
Quishing: when the code itself is the attack
A QR code gives the scanner no visible destination. That is its convenience and its vulnerability.
In a quishing attack, someone prints a malicious QR sticker and places it over a legitimate one. Parking meters, restaurant table tents, EV charging stations, and public poster boards are common targets because the real code is already expected there. The victim scans, lands on a convincing payment page, and enters card details, and nothing feels unusual because scanning to pay for parking is now normal behavior.
The defense is simple and almost nobody uses it. Most phone cameras preview the destination URL before opening it. On iPhone, the notification that appears after scanning shows the link text. On Android, the browser usually shows the address bar before the page finishes loading, and many camera apps surface the URL in the scan prompt. Look at it. If a parking meter code points to a domain that has nothing to do with the city or the parking operator, do not proceed. If a restaurant menu code opens an unrelated shortener with a random string, be suspicious.
The same rule applies to codes you did not place yourself. A sticker that looks raised, crooked, or layered over another sticker is worth treating as hostile.
Test with multiple phones, not just yours
Your phone is the worst possible test device: it is the one you built the code on, it is probably newer than average, and its camera has been staring at this specific code for twenty minutes.
Test on at least three devices: one recent iPhone, one recent Android, and one older or cheaper phone if you can find one. Test in the actual lighting conditions, not in a bright office. Test at the actual distance a customer will stand. Test after laminating, because a glossy surface changes reflections. And test with the phone's default camera app, not just a dedicated scanner app, because that is what most people use.
If all three pass in real conditions, you have a code that works. If only yours passes, you have a code that works for you.
Choosing a QR code generator that will not expire
If you need a permanent code that never expires, generate it with a static QR code generator that creates codes with no expiration. The destination lives in the ink, so there is no subscription to lapse and no server to go dark.
For general use, the free QR code generator covers URLs, text, phone numbers, and the common formats, with control over error correction and output size. If you are encoding a network, a dedicated WiFi QR code generator handles the credential format correctly so guests are not typing a 24-character password on a phone keyboard.
And if you are on the receiving end, unsure whether a code is safe, a QR code scanner that previews the destination lets you inspect the link before you commit to opening it. That is the habit that defuses quishing.
For the technical background, the Wikipedia article on QR codes covers the encoding structure, versions, and capacity tables in more depth than any marketing guide will.
Frequently asked questions
Do QR codes expire?
Static QR codes never expire. The data is stored inside the code itself, so there is no server involved and nothing that can be switched off. Dynamic QR codes can expire when the redirect service stops running, which typically happens when a subscription lapses or the vendor shuts down.
How much data can a QR code hold?
Capacity depends on the data type and error correction level. In practice, a QR code can hold roughly 3,000 characters of alphanumeric text or about 7,000 numeric digits at the highest capacity version. The largest versions are extremely dense and difficult to scan from any real distance, so practical codes stay well under 300 characters.
Why does my QR code stop working after a few months?
The most common cause is a dynamic code whose subscription ended. The second most common is a changed destination: the page the code points to was moved or deleted. The third is physical: the print faded, the surface got scratched, or a sticker was placed over it.
Can I change the link in a QR code after printing?
Only if the code is dynamic. A dynamic code points to a short redirect that the vendor controls, so the destination can be updated without reprinting. A static code contains the destination directly, so changing it requires generating and printing a new code.
Why does my QR code work on my phone but not on others?
Older cameras, lower-resolution sensors, and weaker autofocus struggle with dense codes. Your phone may also have cached the code during testing. Print larger, shorten the URL, raise the contrast, and restore the quiet zone, then retest on an older device.
What is the quiet zone and why does it matter?
The quiet zone is the blank margin around the code, ideally about four modules wide on every side. Scanners use it to locate the code's boundaries. Cropping it to make the design look cleaner is one of the most common causes of scan failure.
Does a logo in the middle break the code?
Not if the error correction level is high enough. At level H, roughly 30 percent of the code can be obscured and still recovered. A logo covering 15 to 20 percent of the area is generally safe at that level, provided the code is printed large enough to compensate for the added density.
Are QR codes safe to scan?
Most are. The risk is quishing, where a malicious sticker is placed over a legitimate code. Preview the destination URL before opening it, and be skeptical of codes on public infrastructure that point to unrelated domains.
Why do short URLs make better QR codes?
Fewer characters produce fewer modules, which produces a sparser grid at the same print size. Sparser grids are easier for cameras to resolve at a distance, on curved surfaces, and in poor light. Shortening a URL can turn an unscannable code into a reliable one without changing the print.
What is the minimum size for a QR code?
About 2 by 2 centimeters, roughly 0.8 inches, for a short URL scanned at close range. Longer data and greater viewing distance require larger codes. A reasonable rule is one tenth of the scanning distance.
The bottom line
A QR code is a container, not a picture. Static codes hold the data and last as long as the ink. Dynamic codes hold a redirect and last as long as the subscription. Everything else, the error correction level, the URL length, the quiet zone, the contrast, the print size, is a variable you control at design time and cannot fix after printing.
Dana's table tents were fine. Her code was fine. She had rented a redirect and stopped paying rent. If you take one thing from this, make it the question you ask before you print anything: does this code contain my destination, or does it contain a promise from someone else?
No comments:
Post a Comment