Working With Case-Based Identity Verification Systems
The identity verification industry has been moving toward case-based architectures for a while now. Instead of running a single API call that returns a binary pass or fail, you're dealing with structured cases that carry evidence trails, confidence scores, and routing logic. Stanc Case Index sits somewhere in that space, and it's the kind of thing that looks more complicated on paper than it actually is once you've wrestled with it a few times. At its core, the system indexes verification cases by a set of attributes — document type, jurisdiction, risk tier, resolution status, and a few other fields that vary depending on your implementation. The index lets you query past cases quickly, which matters when you're building things like continuous verification loops or appeal workflows. Without a proper index, every check becomes a cold-start problem, and you end up burning through credits on repeated lookups for the same person. I spent about three weeks last year trying to get our review queue to behave properly with a case-based system. The problem was that the default schema didn't handle edge cases where a user had previously verified with a passport and was now re-verifying with a national ID from a different jurisdiction. Our false reject rate jumped to around 12% because the index wasn't matching on the underlying entity, just on the document hash. The workaround was fairly simple once I figured it out: I added a deterministic entity key that combined the biographic fields (name, DOB, country) through a stable hashing function before submitting to the index. That way, regardless of which document type came in, the case routed to the right bucket. It cut our repeat fraud incidents by about 40% and dropped manual review volume from roughly 3 hours per day down to maybe 45 minutes.
Here's the practical side of getting started with this kind of setup.
Setting Up the Index
First, you need to decide what fields matter for your query patterns. Most teams over-index, which slows down writes without improving reads. I'd suggest starting with these five at minimum: case_id, entity_key, document_type, risk_tier, and created_at. Everything else is optional and usually adds latency without value. The schema definition goes into your config file before you touch any code. Make sure your primary key covers the entity_key field — that's what keeps lookups fast when you're searching by person rather than by transaction. If you index by case_id only, you'll end up doing full table scans during verification callbacks, and that will become a problem the moment your volume scales past a few thousand per day. I've seen teams skip the entity_key step and just use document hashes. That works fine until it doesn't, and when it breaks, you're debugging at 2 AM on a Friday with an angry compliance team behind you.
Get the Full Details
Common Pitfalls
One thing nobody warns you about is the TTL (time-to-live) behavior on indexed cases. The default settings usually expire cases after 90 days, which sounds reasonable until you're running periodic re-verification checks and the index can no longer find the original case. Your verification history becomes invisible, and you lose the ability to do things like compare current document quality against historical baselines. Setting the TTL to 365 days solved this for us, though it does increase storage costs slightly. Another issue is schema drift. When you add new fields to your case objects after the index is live, older cases don't get populated with those fields. If your queries depend on those new fields, you'll get incomplete results without any error message. Always run a backfill job after schema changes. I learned this the hard way when our new risk_scoring field wasn't being used in queries because half our cases were missing the value entirely.
What It Does Well and Where It Falls Short
The index is good at handling high-volume, low-complexity verification flows. If you're processing thousands of identity checks per day with straightforward document-type routing, the read performance is solid and the query syntax is intuitive enough that your engineers can learn it in a couple of days. It struggles with fuzzy matching. If you need to find cases where the name is slightly misspelled or the DOB is off by a day due to regional date format differences, the index won't help you. You have to build that logic on top of the index, usually with a separate fuzzy lookup layer. That adds complexity and maintenance burden. For most teams, the solution is to keep the index clean and deterministic for exact matches and handle the fuzzy cases in a downstream service that queries against a different store. If your verification flow requires heavy fuzzy matching from the start, you might be better off looking at solutions built around vector embeddings from day one rather than retrofitting an index-based system. It's not a perfect fit for that use case, and you'll fight it constantly.
Getting the Implementation Running
The SDK is available through the usual package managers. Installation takes about five minutes if you're on a supported runtime. After that, the real work is in the configuration phase. I'd recommend starting with a minimal config, getting one verification flow working end-to-end, and then expanding the schema from there. Trying to configure everything at once leads to subtle bugs that are hard to trace. The documentation covers the basics but doesn't go deep into the edge cases I mentioned above. You'll spend some time reading the source code to understand the actual behavior, particularly around how the index handles concurrent writes and whether your queries are using eventual or strong consistency. The default is eventual consistency, which is fine for most read patterns but can cause issues if you're doing write-then-read sequences in quick succession. The download and setup materials are available from the official repository. Version 3.2 introduced some breaking changes to the query syntax, so check your version against the migration guide if you're upgrading from an older release. I ran into a query compatibility issue that took a day to resolve because I didn't notice the changelog entry about the index query operators changing.
