How we test and score memory cards
Every number in a CKBench review comes from one results file, produced by a bench we built because the marketing figures answer almost none of the questions that matter. This page is the method behind those numbers, the rubric behind the scores, and an honest list of what we do not test.
Every byte committed, every byte verified
Two rules shape everything else. The first is that a write does not count until the card confirms it. All test writes use unbuffered write-through handles and the timer stops only after the flush returns, so nothing is credited to the card that is actually sitting in the computer's memory. This is why our write speeds read lower than burst benchmarks like CrystalDiskMark: a burst benchmark measures a card's small RAM buffer for a few seconds, and we measure what the card sustains when the data has to land. Read speeds match CrystalDiskMark within a couple of percent, which is how you can tell the gap is method rather than a slow sample.
The second rule is that data is checked, not assumed. Every test byte is generated from a seeded random stream and compared on read-back, so a card that drops, zeroes or repeats data cannot hide it. A cache-leak canary runs before anything else and aborts the whole run if any read comes from the operating system instead of the card.
The tests only ever create and delete their own files, and the tool refuses to touch a fixed disk without an explicit override.
What actually gets measured
| Test | What it answers |
|---|---|
| Cache-leak canary | Is the operating system lying to us? Writes and re-reads a small file twice before any measurement is trusted. |
| Sequential read and write | The headline speeds, three passes each, every byte committed. |
| Random 4K | Small scattered operations, the workload that matters for app storage and the A-class floors. |
| Sustained write | Five minutes of continuous writing with the cooling fan off. Produces the worst ten-second window, which is what sets a video speed class. |
| Settle pre-pass | An untimed warm-up so the measured window starts on a controller that has finished reacting to the previous test rather than one still cleaning up. |
| Capacity fill and verify | Fills every free byte with unpredictable verifiable data, then reads all of it back and compares. The only test that catches a fake. |
| Position sweep | Throughput at the start, middle and end of the card's address range, where tiered fake flash shows its seams. |
| Thermal | An infrared frame captured the instant the timed write stops, because a card sheds heat in seconds. |
The verdict that decides a video speed class always comes from the worst ten-second window, never the average. A class rating is a promise the card has to keep for the whole recording, and your camera does not get to record over the average.
How the score is built
Every review carries a score out of 5. It is the mean of five dimensions, each scored out of 5 and rounded to the nearest half point, and it is category-relative: a card is judged against the job it is sold for, not against an SSD. A dash cam card that streams video beautifully and is mediocre at random reads is doing its job. Every review publishes its own breakdown, so you can see which dimension moved the number and disagree with us specifically rather than generally.
Claim accuracy
Does the card do what its label says? Every printed mark is checked against a measurement: capacity, speed class, UHS grade, video class, app class. Claims a bench cannot settle in one session, like endurance hours, are listed as not testable rather than quietly dropped.
Sustained performance
The worst ten-second window across five minutes of continuous committed writing, judged against the classes the card prints and the real workloads people record. Includes whether the write curve has a cache cliff hiding in it.
Endurance behavior
How much random-write performance the card loses under the scattered-write churn that loop recording produces. This is a directional indicator, not an endurance test: no bench session can tell you a card will still be working in year three.
Capacity integrity
Is the space real? Measured by filling the entire card with verifiable data and reading every byte back. Counts both how much usable capacity the card delivers against its label and whether every byte survives the round trip.
Thermal behavior
Peak surface temperature at the end of an uncooled sustained write, judged three ways: whether the card slowed down on the way there, how much headroom is left under the 85 C these parts are typically rated for, and how much heat it produced for the work it did. Heat that throttles is a fault. Heat that costs no speed is a fact, but a card that reaches the same temperature for a third of the throughput has less margin when the ambient rises, and that counts against it.
Two rules that override the average
The capacity disqualifier. A card that materially misrepresents its capacity is capped at 1 out of 5 regardless of every other dimension. Speed is irrelevant when the space is not there, and a counterfeit that happens to be quick is still a counterfeit. The ImageMate counterfeit is the reason this rule exists: its five dimensions average 2.4 and it is published as a 1.
No score without a complete run. A card is only scored when the sustained write, the random 4K passes and the full capacity fill and verify all completed. A partial run gets published as a partial run, with the missing leg named, and no number attached.
Conventions we hold to
| Convention | Why |
|---|---|
| Throughput in decimal MB/s | 1 MB is 1,000,000 bytes, because that is what card labels and the SD video speed class floors mean. Quoting binary here would flatter every card by about 5%. |
| Block sizes in binary MiB | 1 MiB is 1,048,576 bytes, because that is what the drive actually moves per operation. |
| Capacity in decimal GB | Same reason as throughput: it is the unit on the label. Your computer counts in binary, which is why a genuine 128 GB card displays as about 119 GB. |
| Read speed is reported with the reader named | Card readers are not interchangeable. Standard UHS-I signalling tops out around 96 to 97 MB/s, and some readers support a faster non-standard mode that some cards can use. Every card is benched on the same reader so the corpus stays comparable, and a second, separately characterized reader is kept as a control rather than run routinely. It comes out to check anomalies in either direction: a result that looks wrong, and equally a result that looks too good for the card's class, since a card reading above the UHS-I ceiling is as much an anomaly as one reading far below it. Where the two readers disagree we publish both numbers, because a figure you cannot reproduce on ordinary hardware is not much use to you. |
| Anomalies are diagnosed with a known card, not a re-run | When a run looks wrong, re-running the same card tells you little. Putting a card whose numbers we already know through the suspect path isolates the reader from the card in one pass. That is how the counterfeit's slow session was traced: a card with a five-day-old baseline went through the same reader and returned figures within 1% of it, which cleared the hardware and pointed at the card. |
| A-class results are indicative | Our random 4K procedure differs from the SD Association's, and read IOPS on a USB reader sit near a bus-imposed ceiling around 1600, which is uncomfortably close to A1's 1500 floor. A2 is not testable at all on USB readers, whose floors assume command queuing they do not perform. |
| No prices, ever | Card prices move faster than we can maintain them, and stale pricing is worse than none. We record what we paid in the card's internal record and link the live listing instead. |
What we do not test, and why
A method is only credible if it names its own gaps. These are ours.
Power loss. Sudden power removal mid-write is arguably the most common way a card fails in a dash cam, and nothing in our suite touches it. Doing it properly needs switchable power hardware and a protocol that deliberately risks the card and its filesystem, so it is a separate project rather than a line item. Every result we publish describes a card that was never interrupted.
Real endurance. We measure how a card behaves under churn, which is a good directional read on whether it was built for loop recording. It is not a measurement of lifespan, and nothing done in an hour can be. Manufacturer endurance ratings are reported with their published conditions attached and marked as not testable in session.
Sample size. Each review is one retail unit, with one run on most phases and three passes inside each speed test. That characterizes the card in our hand and gives us a fingerprint to compare future cards against. It cannot see unit-to-unit variation across a production line, and for counterfeits there is no product line to generalize about at all.
Long-term retention. How well a card holds data sitting unpowered in a drawer for a year is a real question and we have no way to answer it on this timescale.
Who pays for the cards
We buy the cards we test, or they arrive inside a device we bought. No manufacturer has supplied a card, seen a result before publication, or had any editorial input, and each review states how that specific unit was acquired. Where a review links to a product it is usually an affiliate link, disclosed on the page, and the link never changes a number. CK Tech Check runs no advertising of any kind.
If a card we recommended turns out to be wrong, the correction goes on the page rather than quietly into the archive. Two of the reviews currently published carry amendments made after the fact, both marked.
See the method applied
Three cards tested end to end so far: one that beat its own label, one that quietly keeps four gigabytes for itself, and one that is not the size it says it is.
Browse CKBench