A bank is building an AI-powered credit card fraud prevention system that must analyze transactions within milliseconds to block fraudulent charges. At the same time, the system needs to retrain its models daily using terabytes of historical transaction records. Which architectural design is best suited to satisfy both requirements?
Select an answer to reveal the explanation.
Short Explanation and Infographic
Here's the deal: you can't train a massive fraud detection model on the same tiny device that's supposed to authorize a credit card transaction in under 50 milliseconds. That's like trying to rebuild a car engine while you're driving it down the highway! In the real world, we split these tasks up. We use a heavy-duty, multi-GPU cluster back in the datacenter to crunch terabytes of historical data and train the model. Then, we push that lightweight, optimized model out to the edge—closer to where the transactions are happening—so it can score swipes instantly without waiting for a long roundtrip network delay. This hybrid setup gives you the best of both worlds: massive training horsepower and lightning-fast inference. Got it? Sweet. Let's keep rolling.
Full explanation below image
Full Explanation
Designing enterprise AI systems often involves separating training and inference workloads because they have vastly different compute, memory, and latency profiles. Model training is throughput-bound, requiring huge amounts of memory and floating-point computation to process massive historical datasets. Inference is latency-bound, requiring fast response times to act on live data. In this banking scenario, transaction authorization must occur within milliseconds. Relying on a centralized cluster for both training and inference (Option A or D) introduces network latency bottlenecks and resource contention. An edge-only deployment using low-power ARM processors (Option C) lacks the computational capacity required to retrain deep learning models on terabytes of daily transaction data. The optimal solution is a hybrid architecture (Option B). Centrally located, high-throughput multi-GPU servers train the model on accumulated historical data. Once trained, the optimized model weights are deployed to local edge servers or devices (near the transaction endpoints) to perform low-latency, real-time inference. This separation ensures that the model can be continuously updated without impacting the strict response times required for transaction processing.