Feature Stores vs Inline Compute: Real-Time Decisions Without Training Skew

# features/choose.py
def choose(shared: bool, p99_ms: float, needs_pit: bool, cpu_us: float) -> str:
 if needs_pit or shared:
 return "online_store"
 if cpu_us < 500 and p99_ms > 30:
 return "inline" # ✅ cheap & local
 if p99_ms < 15 and shared:
 return "online_store_precompute"
 return "hybrid_keys_inline_enrichment"

# features/definitions.py — shared by training + serving
from dataclasses import dataclass

@dataclass(frozen=True)
class AmountZScore:
 name: str = "amount_zscore"
 window_hours: int = 24

 def compute(self, amount: float, mean: float, std: float) -> float:
 return 0.0 if std == 0 else (amount - mean) / std

// serving/features.ts — same formula, generated or shared lib
export function amountZScore(amount: number, mean: number, std: number) {
 return std === 0 ? 0 : (amount - mean) / std; // ✅ identical to Python
}

// serving/fetch.ts
export async function fetchFeatures(entityId: string, names: string[]) {
 const item = await ddb.get({
 Key: { pk: `entity#${entityId}`, sk: "features" },
 ProjectionExpression: names.join(","),
 });
 // ✅ Fail closed or fall back per model policy
 if (!item.Item) throw new Error("features_missing");
 return item.Item;
}

def test_parity_amount_zscore():
 samples = load_golden_batch("amount_zscore")
 for s in samples:
 offline = AmountZScore().compute(s.amount, s.mean, s.std)
 online = inline_ts_equivalent(s.amount, s.mean, s.std)
 assert abs(offline - online) < 1e-9