Hello and welcome. I'm Kota and I'm excited to share with you our work on real time fraud detection for e-commerce platforms. Specifically, we focus on stopping fake reviews, which have become a major threat to customer trust and marketplace integrity. I always read reviews before I buy something online. Once I saw a toaster review, which has five stars because it changed someone's life. Now that's a powerful appliance or it's really a bad fake review. Jokes aside fake reviews like that can really mislead. People. And today I'll walk you through challenges we face, the system we that was built and how it's already making an impact on scale. Let's go. Go ahead. So now we are in marketplace integrated challenge. E-commerce thrives on trust today. Every time you buy something online, you probably check the reviews first. You trust those reviews are harnessed, written by real people who actually use the product. But fake reviews actually break the test. Imagine buying something highly rated only to find, it's nothing like the reviews. You feel cheated and you might think again twice before shopping on that platform. This is a real danger. And it doesn't just affect customers. Harness sellers are even pushed down by the competitors who achieve the system, and even platforms lose credibility. I. Now frauds. These fraudsters are not just writing random fake reviews. They're running some coordinated campaigns using many fake accounts. These accounts are often well planned with detailed profiles and the post reviews in a way that they look natural and the faster they post. The more damage they cause. That's why speed is critical if we don't catch these fake reviews as they happen. They influence buying decisions and can lead to major financial lo losses for both sellers and as well as platforms. Now, how do we solve this? In order to solve this we built a system designed for speed and scale. First, we use Apache Kafka to handle the flow of reviews. Think of Kafka as a real time data pipeline. It can handle like millions of reviews per second, and it's even fault tolerant, meaning even if something goes wrong, it keeps working. Next we process the data using Apache Flink. Flink is a powerful, is very powerful for stream processing, allowing us to react to new data with like sub millisecond latency. This means we can even detect fraud as it's happening. Then our fraud detection model kicks in. These models are deployed in a horizontally scalable way. As traffic increases we just add more. Server and predictions still happen in just a few milliseconds. Finally, to find more complex fraud, like group of fake accounts, we can actually use a custom graph database. This database helps us map relationships between accounts reviews, products, allowing us to uncover all the hidden patterns. That suggest a coordinated fraud that's happening. Now let's talk about so this is, now that we have seen an architecture behind that system, let's dive deep into how we actually detect the fraud specif, specifically how our systems make decisions about whether a review is genuine or fake, use a hybrid approach, and why a hybrid approach. Fraud isn't just one dimensional. It doesn't always look the same. Some fraudsters even might use simple and repetitive language interviews. Others might try to behave like normal users, but post at really strange times or coordinate on groups. Because of this, relying on just one detection method would leave gaps. That's why we use a hybrid detection approach. Combining several powerful techniques that together create much more reversed and accurate detection system. Let me walk through the key components of this approach. First ensemble edition models like we use ensemble learning. Think of like team of specialists where each model and the and symbol focuses on different kind of signals. One model might specialize in detecting unusual posting times. Another might analyze the content of the review, yet another might look at the history of that user account. These models work together and combined result is often more reliable than any single model acting alone. Example, one example would be like, imagine one model says that this review is fake because of the timing, but another says this language looks okay. When combined, the ensemble can weigh these opinions and decide more accurately. This method helps us reach high precision rate, meaning we can make fewer mistakes when flagging something as fake. Next we bring graph neural networks. This is where we move from looking at individual reviews, to looking at connections between users and reviews. Fraud is often coordinated. A multiple accounts might work together to boost a product or even damage a competitor. Janin help us analyze who is connected to whom. They look at pattern across entire network sporting clusters of suspicious activity. For example, if 10 accounts are frequently reviewed, reviewing the same products around same times, and they're giving very similar ratings, that's the sign might be part of a coordinated fraud Group. Journals allow us to visualize and analyze this behavior effectively. Behavioral analytics is the next one. We also look at like the user behavior. How often the user is posting reviews? Do they really post at times when users, most users don't? Are they interacting with products in ways that. Don't make sense. This helps us catch anomalous behavior that might be visible in the text or in the network connections. Example, if if a user suddenly posts reviews in 10 minutes or only ever reviews products in one category from one seller, it actually resists a red flag. Behavioral analytics. Analytics is very crucial for early detection. Often we can catch fraud starts as they begin their activities. Next is natural language crossing. Finally, we analyze the text of the reviews themselves using natural language crossing. Fake reviews often use overly positive language, like they follow similar pattern across. Multiple reviews contain generic or template like sentences. I. Our NLP tools analyze the structure of review, like syntax, semantics, used word choice, even identifies signs that it was generated or manipulated. If for example, like if fire reviews are poster on the same product, I'll say this is the best product I have ever bought. Highly recommended in nearly identical phrasing. N LP can flag this as likely fake. We can also detect a machine generated text, which is becoming more common as fraudsters use AI tools themselves. Putting all these four together each of these methods like enseal models, gnn peer analytics and NLP brings a unique perspective alone. They can miss things together, they create a multi-layered defense. This hybrid EPO approach allows us to be faster, more accurate, and more adaptive as fraud techniques evolve. And most importantly, this layer method. This layer method helps us to reduce false postures, so real reviews don't get wrongly flagged and it also improves recall, so we catch more of the actual fraud. Let's dive a little deeper into how our hybrid detection system performs. When we talk about performance we are mainly looking at three key metrics, precision recall, and F1 score precision. This tells us out of all the reviews that were flagged as fake, how many were actually flake. Fake, sorry. A high pressure means that we are making fewer mistakes and we say something is fraudulent. Recall. This actually tells us out of all fake reviews out there, how many we actually caught a high recall means we are not missing much. And then there is this F1 score. Which is a balance between precision and recall. It's a great, like a great measure of the overall effectiveness of the system. Now, why this is important, like 'cause many fraud detection systems might be like too strict or too loose. A strict system can actually catch a lot of fake reviews, but also flag real ones that's bad for user trust. A loose system might let too many fake reviews slip through. That hybrid approach, we strike a right balance. Our ion is high. So when we say a review is fake, it usually is. Our recall is also strong, meaning we catch more fake reviews that are out there together, gives us an F1 score that is significantly better than just using single detection method. For example, like when we compare just using NLP alone, we notice that it's struggle with detection, detecting more fraud, like when fraudsters were slightly more natural sounding text. Behavioral models alone might f mis fake accounts that don't just post often. Graph based models are strong, but need more data to kick in. By combining all these three, we cover each other's blind spots. That's why our performance is better across the board. Next is one of the most complex and dangerous types of fraud we face are coordinated campaigns, fraud, fraudsters don't always act alone. They often operate in groups. They've been set up multiple fake accounts, often over weeks or months, and then launch an attack, like pushing fake reviews all at once to promote or damage a product. Now many systems can only detect this type of fraud after it becomes very obvious, like when hundreds of accounts are involved. But our system is designed for early detection. We can even catch these campaigns when there are as few as eight accounts working together. How? How do we do that first? We actually set thresholds for what's considered suspicious. For example, if eight accounts post reviews on the same product within short time window and they never interacted with that product before, that's suspicious. Then we use graph analysis. We create a map of relationships, who posted what, when, and where. If we see the tight clusters of that activity that don't match normal user behavior, that can be treated as a red flag. Now, what's unique is that we don't need massive data to start detecting fraud. Our systems use temporal pattern analysis, which allows to spot fraud from minimal activity, giving us major advantage. This early detection reduces the impact of fraud instead of reacting after the damage is done, we prevent it from spreading in the first place. Now, let's shift gears and talk about privacy, which is a huge concern today, stopping fraud. Is very important, but doing it while protecting user data is even more important. Users trust pla these platforms, not just with their money, but with their information. We use several cutting edge techniques to keep the data safe, use federated learning, like instead of pulling all the user data into one central place to train our models, we train these models locally in defense service. This means like sense two data would never go of the original system. The model learns from the data, but the data itself stays put. Differential privacy. Even when we aggregate results, we add bit of mathematical noise to the data. This ensures that no one can trace a result pack to a specific user. The balance here is key, where we maintain high accuracy but without risking privacy. Encrypted inference. This is really advanced. Using homomorphic encryption, we can actually process data while it's encrypted. Imagine being able to check for fraud without ever seeing the raw data. This protects users even further, especially in a regulated environments. Why is this important? 'cause many fraud detection systems compromise privacy by needing access to detailed user data. Us doesn't we respect users' privacy while still keeping fraud detection fast and even accurate. Now let's talk about scalability. How well our system handle growth. E-commerce platforms face huge spikes in traffic. Think like on Black Friday or even holiday sales or flash deals during these times. The volume of reviews can increase by five times or more. Our system is designed to scale seamlessly. It can handle five x more traffic without any slowdown, even at peak times. It keeps the response time low around 10 milliseconds. We achieve this near linear scaling. This means if you double our servers performance almost doubles. Just about 5% overhead. Also, as the traffic doubles, CPN memory usage only grows by about 1.5 x times. This keeps the system efficient. This is very important because fraudsters also strike during bus busy periods, knowing that detection systems might be overwhelmed. Our system, we can confidently say no matter how big the traffic search, fraud detection continues smoothly with no compromise on speed or accuracy. Next, moving to production deployment, I. This system isn't just in a test environment, it is actually running live, and the result speaks for themselves. It's deployed across like 12 major e-commerce platforms, handling like billions of reviews. We have even seen a 78% drop in fake reviews, meaning that our detection system is working in real world conditions. We have also seen a 94% reduction in false positives. Which means real reviews are staying up and users aren't being wrongly penalized. High availability is key. Like our system runs with 99 per 0.99% uptime, even if something goes wrong in one part of the system. We have this redundant infrastructure and geographical distribution, so the systems keep running and we just don't stop improving. Our models are retrained daily basis. When we detect these new fraud patterns, the system adapts within 24 hours, keeping us ahead of evolving threats. This kind of real world performance shows that system is reliable, adaptable, and effective at scale. Now let's take a closer look at how we build a system to be flexible, efficient, and able to evolve over time. Fraud patterns are generally constantly changing and our system needs to adapt quickly without d downtime or performance loss. Here is how we have designed for that. First, we're using mic microservice based architecture like our system is. Built on microservices. This means like each component, like data ingestion, fraud detection, or graph analysis, it's de developed and deployed independently. If we want to upgrade just our NLP model, we can do that without touching the GNN or behavioral nce. It also makes the system resilient. If one part needs maintenance or scaling, the other keeps running smoothly. For example, we recently introduced a new detection algorithm spec specifically for flash shell fraud. We rolled it out just that part of system without disrupting the entire platform. Next is data structure optimization. To make the system not only scalable, but even resource efficient, we optimized our data handling. We use customs Pass Graph Representations, which means like we don't store unnecessary connections. This reduces our memory footprint by 40% with allow, allowing us to handle more data with fewer resources. And it also improves query performance by three three x. So when we need to check a suspicious user connections, it happens fast. Stateful Next is Stateful Processing with Apache Flink. Many fraud patterns emerge over time. We use stateful processing with Flink and R DB as a backend to store user actions and context over extended periods. This lets us detect fraud that develops gradually, like an account that behaves well for months. Then suddenly act it becomes act two in fraud. We don't just look at these isolated events. We even track the behavior over time, adding depth to our detection capabilities. Next is deployment pipelines. We use use rapid updates. Rapid updates are really critical in frightening this fraud We have. Set up an automated continuous integration or continuous deployment pipelines. This means every time we improve a model or add edition rule, we can test it, validate it, and deploy it without downtime. We use AB testing framework to test all these new features on a small percentage of data before rolling them out. Widely canary deployments help also help us monitor new changes in production, ensuring stability and performance. Next, developer productivity and rapid experimentation like this architecture also supports rapid experimentation where data scientists can deploy and test new models in a sandbox environment. Once these are validated, those models can be integrated into production pipeline very quickly. This kind of architecture keeps our system future proof. Now, as fraudsters develop new tactics, we are equipped to respond faster with minimal overhead and with confidence that we can say we can deploy safely at scale. Now let's talk about highlight about key takeaways from everything that we have discussed today. Speed matters. Fraud detection needs to happen instantly. If fake reviews linger, they impact trust and sales. Our system directs fraud in under like 10 milliseconds, ensuring users only see high quality trustworthy reviews. Realtime detection is in just a feature. It's a necessity in today's fast-paced e-commerce environment. Accuracy through multimodal detection. No single model can capture all fraud. Our hybrid approach uses and simple models, nns Behavioral Analytics and NLP imp, where it improves detection accuracy by up to 38%. We have reduced false positives so that real users aren't penalized and we have improved recall. So we catch more fraud than the existing traditional systems. This is Privacy by design. Federated learning ensures that data stays local. No raw data moves. Differential privacy is next thing, which adds noise to aggregated reserves, so individual users remain anonymous. Homomorphic encryption allows analysis. Without decryption, offering another layer of protection as user trust is more than catching more important than catching a fraud. It's about safeguarding the data every step of the way. Next, scalable architecture. Our system handles billions of reviews even during five traffic surges such as Black Friday or even major product launches. We achieved this near linear scaling. We add capacity smoothly without compromising performance even as traffic grows. CPUN, memory usage grow efficiently. And finally, this is a proven impact in production. This isn't even a theoretical. We are alive on 12 major platforms, where with 78% fewer fake reviews and 20% fewer false positives with 99% plus percent uptime even during failures or traffic spikes. Daily model retraining with 24 hour eruption to new. Fraud trends only in short, our system is fast enough to act before fraud spreads. Accurate enough to detect complex, evolving fraud, private enough to protect our user data without compromise. And scalable enough to serve the world's largest e-commerce platform without a hitch. Thank you so much for your attention. I hope you found this presentation valuable and that it gave you a clear sense of how we are advancing fraud detection for modern age. Wrapping up, if you need any further information or explore this topic deeper, feel free to. Reach me out. Thanks again for watching and I hope you enjoy the rest of the conference. Thank you.