Fraud infrastructure · sub-10ms decisioning

Score fraud in under 10 milliseconds

Signalcache is an in-memory feature store and scoring cache built for fraud. Stop trading fraud losses against checkout latency — keep every velocity feature, model, and rule on the hot path, and still beat the payment network's clock.

Get early access ▶ Watch it score live

Bring your own models and data — self-hostable in your VPC

Serving latency p99

8.4ms

▼ 6× faster than Redis-DIY

Features on the hot path

200+

velocity · aggregates · vectors

Decisions / sec / node

120K

sharded in-memory engine

Training / serving skew

point-in-time correct by design

score_transaction.py

# One call. Features fetched, computed, scored — in-memory.
from signalcache import Client

sc = Client("sk_live_...")

decision = sc.score(
    entity   = {"card": card_id, "device": device_id, "ip": ip},
    amount   = 248.00,
    features = ["card_txn_velocity_5m", "device_distinct_cards_24h",
                "ip_risk_score", "amount_zscore_30d"],
    model    = "fraud_v7",
)

# → decision.action = "decline"  ·  score = 0.94  ·  4.8ms
# → reason_codes = ["velocity_spike", "new_device"]

The fraud latency budget

Your fraud model runs against a clock it doesn't control

The payment network gives you a few hundred milliseconds, total. Auth, routing, and settlement eat most of it — leaving fraud scoring a budget of just 20–50ms. Miss it and the network declines the transaction. Cut features to fit and you eat the fraud loss. That tradeoff is a line item on your P&L.

A single card authorization

~300ms total network budget · fraud gets the sliver in blue

Network & routing 132ms 132ms

Auth & settlement 114ms 114ms

Fraud scoring budget ~45ms ~45ms

…with Signalcache 8ms 8ms

What you have to fit fraud into today What Signalcache leaves you to spend on features & models

Architecture

Three planes, one hot path

Ingest events, serve features, and decide — all in memory, all point-in-time correct. Bring your own models and data; we make them fast.

Data plane

Feature store

Streaming ingest of transactions, logins, and device signals. Features defined declaratively — not hand-rolled from Redis primitives.

Sliding-window velocity & aggregation counters
Per-entity feature vectors (card, device, IP, merchant)
Tiered hot RAM → warm NVMe → cold object storage
Point-in-time logging for zero training skew

Decision plane

Scoring & rules

A pluggable model runtime and a versioned rules engine consume served features and return an auditable decision.

ONNX / XGBoost / lightweight NN runtime
Human-readable rules, allow/block lists
Returns score, action, reason codes, features used
Shadow-deploy before going live

Control plane

Ops & governance

Version everything, watch latency and drift, and keep a regulator-ready audit trail for every decision you make.

Feature / model / rule versioning
Latency, freshness & drift dashboards
Full decision audit trail (adverse-action ready)
SSO, RBAC, data-residency controls

Built for fraud, not recommendations

The primitives generic feature stores make you fake

Fraud is write-heavy, high-cardinality, and sliding-window. These are first-class objects here — not things you assemble from SETs and ZSETs at 3am.

Velocity counters

"Txns from this card in the last 60s / 5m / 24h." Updated and read on the same request, at bounded memory.

Probabilistic aggregates

Distinct-device and heavy-hitter features via HLL, count-min, and top-K — exact-enough at a fraction of the RAM.

Entity graphs

Card ↔ device ↔ IP ↔ merchant links traversed at auth time to catch rings and shared-fraud fingerprints.

Point-in-time replay

Every served feature value is logged, so training data matches production exactly. No leakage, no skew.

Blocklists & allowlists

Membership checks as a first-class feature — synced, TTL'd, and readable inside the same sub-10ms budget.

Self-host in your VPC

Your data never leaves your perimeter. Deploy in-VPC for data residency — critical for EU/UK and regulated books.

Positioning

Between raw Redis and black-box fraud SaaS

Redis is too low-level — you build every feature yourself. Fraud SaaS is a black box that holds your data and models. Signalcache is the infrastructure layer in between: you own the stack, we make it fast and correct.

	Redis / DIY	Fraud SaaS (Sift, Sardine…)	Generic feature store (Feast, Tecton…)	Signalcache
Sub-10ms online serving	Maybe, hand-tuned	✗ per-call API	✗ 20–100ms+	✓ by design
Fraud-native primitives	✗ build it all	✓ black-box	✗ not tuned	✓ first-class
You own your models	✓	✗ their models	✓	✓
Your data stays in-VPC	✓	✗ their cloud	Sometimes	✓ self-host
Point-in-time correctness	✗ DIY	✗ opaque	✓	✓
Decision auditability	✗ build it	Limited	✗ n/a	✓ regulator-ready
Time to production	Quarters	Fast	Months	Days

Live demo

Watch it score a live transaction stream

Real velocity features updating, models firing, and accept / decline decisions — each in single-digit milliseconds. This is the engine, running in your browser.

Pricing

Usage-based. Pay for decisions and memory.

Priced on decisions scored and GB-hours of in-memory feature capacity — aligned with the one cost driver that matters. Start free, self-host when you're ready.

Developer

$0 / mo

For prototypes and design partners getting a feel for the engine.

100K decisions / mo
2 GB in-memory features
Core velocity & aggregate features
Community support

Start free

Stop paying for fraud in latency.

Join the early-access program. We'll help you migrate your first feature off Redis in a week.