Heuristic Test Strategy Mnemonics: SFDPOT, CRUD, FCC CUTS VIDS, and More
Experienced testers don't wander randomly when exploring software. They apply structured heuristics — mental frameworks that focus attention on areas where bugs tend to hide. Mnemonics make these heuristics memorable and usable in the middle of a test session without consulting a reference.
These aren't checklists to work through mechanically. They're prompts that trigger questions, and questions that reveal bugs.
Why Heuristics Matter
Exploratory testing without structure produces inconsistent coverage. One tester might spend an hour on happy paths, another on error states, another on edge cases. Heuristics create a shared vocabulary and a systematic way to ensure you've thought about a problem from multiple angles.
The best heuristics come from accumulated experience — patterns of where bugs actually hide. Using established mnemonics means you inherit decades of testing experience without having to rediscover every failure mode yourself.
SFDPOT: San Francisco Depot
Created by James Bach, SFDPOT covers the quality factors most likely to contain bugs in any system:
- S — Structure: The components the product is built from — data, code, UI elements, hardware
- F — Function: What the product does — features, actions, behaviors
- D — Data: The inputs and outputs — fields, files, data stores, configuration
- P — Platform: What the product runs on — OS, browser, hardware, dependencies
- O — Operations: How the product is used — user roles, workflows, usage patterns, errors
- T — Time: Time-related factors — timing, duration, concurrency, scheduling
Using SFDPOT
For a feature like "user password reset":
| Element | Questions |
|---|---|
| Structure | What components are involved? Email service, token store, password validator. What breaks if any fails? |
| Function | Does the link expire? What's the expiry time? Can the link be reused? |
| Data | What characters are valid in the new password? What length limits? Are old passwords rejected? |
| Platform | Does the email render correctly in Gmail, Outlook, mobile? Does the link work in all browsers? |
| Operations | What if the user requests reset twice? What if the email was never confirmed? |
| Time | What's the exact token expiry behavior? Does it expire from send or from click? |
Work through each element, generate questions, and test the interesting ones.
CRUD: The Data Operations Heuristic
For any feature that manages data, verify all four operations:
- C — Create: Can you create new records? What are the constraints?
- R — Read: Can you read them back? All fields? With correct formatting?
- U — Update: Can you modify them? All fields? Partially? What's the audit trail?
- D — Delete: Can you delete? What happens to related records? Is it soft or hard delete?
Common CRUD Bugs
Create:
- Duplicate records allowed when they shouldn't be
- Required fields accepted as empty
- Special characters cause storage errors
Read:
- Pagination skips records at page boundaries
- Fields truncated in display but stored correctly (or vice versa)
- Timezone conversion errors on date fields
Update:
- Concurrent updates last-write-wins when they should merge
- Update triggers cascade that shouldn't
- Optimistic locking not implemented
Delete:
- Orphaned records in related tables
- Foreign key violations on delete
- Soft-deleted records visible through API filters
CRUD Variations
For some systems: CRUDL (add List) — testing filtering, sorting, pagination separately from simple read.
For financial systems: CRUDI — replacing D with I (Inactivate) since financial records are rarely deleted.
FCC CUTS VIDS
A comprehensive heuristic for testing any product. Each letter is a category of test ideas:
- F — Familiar: Familiar things that often cause problems (input validation, error handling)
- C — Claims: Documented claims (spec, help text, marketing materials) — verify they're accurate
- C — Consistency: Internal consistency — does the product behave consistently with itself?
- C — Complexity: Where is the product most complex? Complex areas have more bugs.
- U — Usability: Can a real user accomplish real tasks without instruction?
- T — Timing: Time-sensitive operations, concurrency, timeouts, scheduling
- S — Scalability: Does the product work at the expected scale? And beyond it?
- V — Variations: Multiple instances, configurations, versions, combinations
- I — Interfaces: Integration points — APIs, databases, external services, file imports
- D — Data: Range, boundary, format, special characters, null, overflow
- S — Scenarios: End-to-end user scenarios, not just individual features
Using FCC CUTS VIDS on an API
For a REST API endpoint POST /orders:
- Claims: Verify the API docs match actual behavior — accepted fields, response codes, error messages
- Consistency: Same fields accepted by
PUT /orders/{id}? Error format consistent with other endpoints? - Data: What happens with null fields? Empty strings? Very large payloads? Malformed JSON?
- Timing: Two simultaneous requests for the same inventory? What's the conflict resolution?
- Interfaces: Does the order creation trigger the downstream inventory reservation?
- Scenarios: Full purchase flow — create order, add items, pay, fulfil, refund
HICCUPPS: The Consistency Heuristic
Michael Bolton's heuristic focuses on consistency — one of the most powerful ideas in testing. A product should be consistent with:
- H — History: Consistent with previous versions
- I — Image: Consistent with the organization's reputation and brand standards
- C — Claims: Consistent with what's documented or advertised
- C — Comparable products: Consistent with similar products in the market
- U — User expectations: Consistent with what users would expect
- P — Product: Internally consistent with other parts of the same product
- P — Purpose: Consistent with the intended use case
- S — Statutes: Consistent with legal and regulatory requirements
Inconsistency is a bug indicator. When something behaves differently than similar things, that's worth investigating — either it's a bug or there's a reason, and finding the reason is valuable regardless.
HICCUPPS in Practice
Testing a mobile app's notification settings:
- History: Did this setting work in the previous version?
- Claims: Does "turn off all notifications" actually turn off all notifications?
- Comparable products: Other apps use a toggle here; this uses a dropdown — user expectation mismatch?
- Product: Do notification settings on mobile sync with web settings?
- Statutes: Are GDPR notification preferences honored?
PARIST: Test Conditions Heuristic
For generating test conditions around specific features:
- P — Position: First, last, middle, only one
- A — Adjacency: What's immediately before/after in the flow
- R — Reference: What refers to this, what does this reference
- I — Interaction: Actions that are done together or in sequence
- S — Special values: Zero, null, empty, max, min, boundary values
- T — Time: Creation time, modification time, expiry, ordering
The Big Picture: Combining Heuristics
Heuristics aren't mutually exclusive. Experienced testers move between them fluidly:
- Start with SFDPOT to identify the major risk areas
- Apply CRUD to any feature involving data management
- Use FCC CUTS VIDS to generate specific test ideas within each risk area
- Apply HICCUPPS to identify where inconsistency creates bugs
- Use PARIST to ensure you've covered boundary and edge conditions
A 90-minute exploratory session might move through all of these, with the tester's notes capturing what was found, what was missed, and what requires follow-up.
Documenting Heuristic Sessions
The value of a session is captured in notes, not just in bugs found. Good session notes record:
- Which heuristics were applied to which areas
- What questions were asked (even if the answer was "no bug here")
- What was explicitly NOT tested (to inform future sessions)
- Any bugs found, with reproduction steps
HelpMeTest's structured test recording captures what was done during automated sessions. For exploratory sessions, pairing heuristic mnemonics with session-based test management (charter + time box + debrief) gives you reproducibility without losing the flexibility that makes exploratory testing valuable.
Building Your Heuristic Vocabulary
Start with one mnemonic and internalize it before adding others. SFDPOT is a good starting point — it applies to any system and gives you a structured way to think about test scope.
After a few sessions, add CRUD for data-intensive features. Then FCC CUTS VIDS when you want more systematic idea generation.
The goal isn't to memorize all mnemonics — it's to internalize the underlying questions so that "what time-related conditions might affect this feature?" becomes a natural question, not something you only ask when a mnemonic prompts it.