Software Testing Best Practices

Knowledge Graphs as a source of trust for LLM-powered enterprise question answering That has been our position from the beginning when we started our research of understanding how knowledge graphs increase the accuracy of LLM-powered question answering systems over 2 years ago!  The intersection of knowledge graphs and large language models (LLMs) isn’t theoretical anymore. It's been a game-changer for enterprise question answering and now everyone is talking about it and many are doing it. 🚀 This new paper is a summary of our lessons learned of implementing this technology in data.world and working with customers, and outline the opportunities for future research contributions and where the industry needs to go (guess where the data.world AI Lab is focusing). Sneak peek and link in the comments Lessons Learned ✅ Knowledge engineering is essential but underutilized: Across organizations, it’s often sporadic and inconsistent, leading to assumptions and misalignment. It’s time to systematize this critical work. ✅ Explainability builds trust: Showing users exactly how an answer is derived, including auto-corrections, increases transparency and confidence. ✅ Governance matters: Aligning answers with an organization’s business glossary ensures consistency and clarity. ✅ Avoid “boiling the ocean”: don’t tackle too many questions at once A pay-as-you-go approach ensures meaningful progress without overwhelm. ✅ Testing matters: Non-deterministic systems like LLMs require new frameworks to test ambiguity and validate responses effectively. Where the Industry Needs to Go 🌟 Simplified knowledge engineering: Tools and methodologies must make this foundational work easier for everyone. 🌟 User-centric explainability: Different users have different needs so we need to focus on “explainable to whom?”. 🌟 Testing non-deterministic systems: The deterministic models of yesterday won’t cut it. We need innovative frameworks to ensure quality in LLMs powered software applications. 🌟 Small semantics vs. Larger semantics: The concept of semantics is being increasingly referenced in industry in the context of “semantic layers” for BI and Analytics. Let’s close the gap between the small semantics (fact/dimension modeling) and large semantics (ontologies, taxonomies) 🌟 Multi-agent systems: break down the problem into smaller, more manageable components. Should an agent deal with the core task of answering questions and managing ambiguity, or should these be split into separate agents? This research reflects our commitment to co-innovate with customers to solve real-world challenges in enterprise AI. 💬 What do you think? How are knowledge graphs shaping your AI strategies?

One of the biggest challenges I see with scaling LLM agents isn’t the model itself. It’s context. Agents break down not because they “can’t think” but because they lose track of what’s happened, what’s been decided, and why. Here’s the pattern I notice: 👉 For short tasks, things work fine. The agent remembers the conversation so far, does its subtasks, and pulls everything together reliably. 👉 But the moment the task gets longer, the context window fills up, and the agent starts forgetting key decisions. That’s when results become inconsistent, and trust breaks down. That’s where Context Engineering comes in. 🔑 Principle 1: Share Full Context, Not Just Results Reliability starts with transparency. If an agent only shares the final outputs of subtasks, the decision-making trail is lost. That makes it impossible to debug or reproduce. You need the full trace, not just the answer. 🔑 Principle 2: Every Action Is an Implicit Decision Every step in a workflow isn’t just “doing the work”, it’s making a decision. And if those decisions conflict because context was lost along the way, you end up with unreliable results. ✨ The Solution to this is "Engineer Smarter Context" It’s not about dumping more history into the next step. It’s about carrying forward the right pieces of context: → Summarize the messy details into something digestible. → Keep the key decisions and turning points visible. → Drop the noise that doesn’t matter. When you do this well, agents can finally handle longer, more complex workflows without falling apart. Reliability doesn’t come from bigger context windows. It comes from smarter context windows. 〰️〰️〰️ Follow me (Aishwarya Srinivasan) for more AI insight and subscribe to my Substack to find more in-depth blogs and weekly updates in AI: https://lnkd.in/dpBNr6Jg

Check out this post by MICKAEL QUESNOT 📢 SAP Dummies Guide: Unlocking the Secrets of SAP IDoc Configuration! 🚀 Ever seen diagrams with transaction codes like WE20, BD64, SM59, and wondered how they all connect in SAP? This is your cheat sheet to understanding the backbone of SAP's data exchange: IDocs (Intermediate Documents)! This diagram shows a typical setup for sending and receiving data, specifically illustrated with MATMAS (Material Master) IDocs. Understanding this flow is crucial for anyone working with SAP integrations! --- 🧔At the Heart of It All: The Partner Profile (WE20) Think of WE20 (Partner Profile) as your central address book for IDoc communication. It defines who your SAP system talks to (your "partners" - other systems or business units) and how it talks to them. Inside your Partner Profile, you'll configure: Inbound Parameters: What to do when an IDoc comes into your system. Outbound Parameters: How to send an IDoc out of your system. --- 🕵️♀️ The Key Players in IDoc Communication: Let's break down the other important pieces shown in the diagram: 1. Logical Systems (BD54 & SCC4): Every SAP client (e.g., S18CLNT500, S18CLNT700) needs a unique "Logical System" name. This identifies individual systems in your landscape. SCC4 (Client Settings) helps define these. 2. Message Types (WE81) & IDoc Types (WE30): WE81 (Message Type - e.g., MATMAS): This is the business content of your message (e.g., "Material Master Data"). WE30 (IDoc Type - e.g., MATMAS06): This is the technical structure or blueprint of the IDoc. It defines how the data is organized. WE82 links the Message Type to the IDoc Type, telling SAP which structure to use for which business message. WE31 (Segments - e.g., E1MARAM): IDoc Types are built from smaller blocks called segments, which hold specific pieces of data (like material description or plant details). 3. Model Definition (BD64): This is where you define the ALE (Application Link Enabling) distribution model. It specifies which Message Types are exchanged between which Logical Systems. It's like drawing the communication lines on a map! 4. Ports (WE21) & RFC Destinations (SM59): WE21 (Ports) defines the technical pathway for IDocs. A common type is TRFC (Transactional RFC), ensuring reliable communication. SM59 (RFC Destinations) provides the actual "phone number" (connection details) to reach the other SAP system or external application. 5. Process Codes (WE42): For inbound IDocs, the WE42 (Inbound Process Code - e.g., MATM) tells SAP what to do with the incoming IDoc data. It links the message type to a specific function module (like IDOC_INPUT_MATMAS01) that will process the data and update your SAP system (e.g., create a material). --- #SAP #IDocs #SAPIntegration #ALE #SAPBasis #SAPDummies #MaterialMaster #DataExchange #SAPConfiguration #TechExplained #india #technology

We know the Earth is getting warmer, but not what it means specifically for different regions. To figure this out, scientists do climate modelling. 🔎 🌍 , Google Research has published groundbreaking advancements in climate prediction using the power of #AI! Typically, researchers use "climate modelling" to understand the regional impacts of climate change, but current approaches have large uncertainty. Introducing NeuralGCM: a new atmospheric model that outperforms existing models by combining AI with physics-based modelling for improved accuracy and efficiency. Here’s why it stands out: ✅ More Accurate Simulations When predicting global temperatures and humidity for 2020, NeuralGCM had 15-50% less error than the state-of-the-art model "X-SHiELD". ✅ Faster Results NeuralGCM is 3,500 times quicker than X-SHiELD. If researchers simulated a year of the Earth's atmosphere with X-SHiELD, it would take 20 days to complete —  whereas NeuralGCM achieves this in just 8 minutes. ✅ Greater Accessibility Google Research has made NeuralGCM openly available on GitHub for non-commercial use, allowing researchers to explore, test ideas, and improve the model’s functionality. The research showcases AI’s ability to help deliver more accurate, efficient, and accessible climate predictions, which is critical to navigating a changing global climate. Read more about the team’s groundbreaking research in   Nature Portfolio’s  latest article! → https://lnkd.in/e-Etb_x4 #AIforClimateAction #Sustainability #AI

Conversational AI is transforming customer support, but making it reliable and scalable is a complex challenge. In a recent tech blog, Airbnb’s engineering team shares how they upgraded their Automation Platform to enhance the effectiveness of virtual agents while ensuring easier maintenance. The new Automation Platform V2 leverages the power of large language models (LLMs). However, recognizing the unpredictability of LLM outputs, the team designed the platform to harness LLMs in a more controlled manner. They focused on three key areas to achieve this: LLM workflows, context management, and guardrails. The first area, LLM workflows, ensures that AI-powered agents follow structured reasoning processes. Airbnb incorporates Chain of Thought, an AI agent framework that enables LLMs to reason through problems step by step. By embedding this structured approach into workflows, the system determines which tools to use and in what order, allowing the LLM to function as a reasoning engine within a managed execution environment. The second area, context management, ensures that the LLM has access to all relevant information needed to make informed decisions. To generate accurate and helpful responses, the system supplies the LLM with critical contextual details—such as past interactions, the customer’s inquiry intent, current trip information, and more. Finally, the guardrails framework acts as a safeguard, monitoring LLM interactions to ensure responses are helpful, relevant, and ethical. This framework is designed to prevent hallucinations, mitigate security risks like jailbreaks, and maintain response quality—ultimately improving trust and reliability in AI-driven support. By rethinking how automation is built and managed, Airbnb has created a more scalable and predictable Conversational AI system. Their approach highlights an important takeaway for companies integrating AI into customer support: AI performs best in a hybrid model—where structured frameworks guide and complement its capabilities. #MachineLearning #DataScience #LLM #Chatbots #AI #Automation #SnacksWeeklyonDataScience – – –  Check out the "Snacks Weekly on Data Science" podcast and subscribe, where I explain in more detail the concepts discussed in this and future posts:    -- Spotify: https://lnkd.in/gKgaMvbh   -- Apple Podcast: https://lnkd.in/gj6aPBBY    -- Youtube: https://lnkd.in/gcwPeBmR https://lnkd.in/gFjXBrPe

SAP EDI step by step configuration with tcodes Configuring SAP EDI involves several steps, from setting up communication partners to defining message types and configuring IDoc processing 1. Define Partner Profile (WE20): TCode: WE20 Create partner profiles for your EDI communication partners (customers, vendors, etc.) Define inbound and outbound parameters, such as message types and port details. 2. Define Logical System (SALE): TCode: SALE Define logical systems for internal and external partners Assign client-specific logical system names and assign RFC destinations 3. Define Message Type (WE81): TCode: WE81 Define message types for inbound and outbound communication Link message types to basic types and IDoc types 4. Assign Message Type to Partner (WE82): TCode: WE82 Assign message types to partner profiles Define inbound and outbound message types for each partner 5. Define Ports (WE21): TCode: WE21 Define ports for communication with external systems Assign communication method (e.g., File, RFC, HTTP) and specify additional parameters 6. Define Partner Function (WE19): TCode: WE19 Define partner functions for inbound and outbound processing Assign partner functions to partner profiles 7. Create Distribution Model (BD64): TCode: BD64 Create distribution models to define the flow of IDocs between logical systems Assign message types and logical systems to the distribution model 8. Define Change Pointers (BD61): TCode: BD61 Define change pointers for master data and transactional data Activate change pointers for relevant message types 9. Configure Process Codes (WE41): TCode: WE41 Define process codes for inbound and outbound processing Assign function modules to process codes for IDoc creation, posting, etc 10. Define Partner Agreement (WEA1): TCode: WEA1 Define partner agreements to specify the exchange protocol, sender/receiver details, and additional settings Assign partner profiles and ports to partner agreements 11. Monitor IDoc Processing (WE02, WE05): TCodes: WE02, WE05 Monitor inbound and outbound IDoc processing Check IDoc statuses, errors, and processing logs 12. Maintain Filters (BD64): TCode: BD64 Define filters to control the distribution of IDocs based on message types, logical systems, etc 13. EDI Mapping (WE42): TCode: WE42 Define EDI message mappings to convert external data formats (e.g., ANSI X12, EDIFACT) to internal IDoc format and vice versa 14. EDI Test (WE19): TCode: WE19 Perform end-to-end testing of EDI scenarios with partner profiles and message types Simulate inbound and outbound message processing to validate configurations 15. Activate Change Pointers (BD50): TCode: BD50 Activate change pointers for specific message types and IDocs Ensure change pointers are active for relevant objects to trigger IDoc creation

Why would your users distrust flawless systems? Recent data shows 40% of leaders identify explainability as a major GenAI adoption risk, yet only 17% are actually addressing it. This gap determines whether humans accept or override AI-driven insights. As founders building AI-powered solutions, we face a counterintuitive truth: technically superior models often deliver worse business outcomes because skeptical users simply ignore them. The most successful implementations reveal that interpretability isn't about exposing mathematical gradients—it's about delivering stakeholder-specific narratives that build confidence. Three practical strategies separate winning AI products from those gathering dust: 1️⃣ Progressive disclosure layers Different stakeholders need different explanations. Your dashboard should let users drill from plain-language assessments to increasingly technical evidence. 2️⃣ Simulatability tests Can your users predict what your system will do next in familiar scenarios? When users can anticipate AI behavior with >80% accuracy, trust metrics improve dramatically. Run regular "prediction exercises" with early users to identify where your system's logic feels alien. 3️⃣ Auditable memory systems Every autonomous step should log its chain-of-thought in domain language. These records serve multiple purposes: incident investigation, training data, and regulatory compliance. They become invaluable when problems occur, providing immediate visibility into decision paths. For early-stage companies, these trust-building mechanisms are more than luxuries. They accelerate adoption. When selling to enterprises or regulated industries, they're table stakes. The fastest-growing AI companies don't just build better algorithms - they build better trust interfaces. While resources may be constrained, embedding these principles early costs far less than retrofitting them after hitting an adoption ceiling. Small teams can implement "minimum viable trust" versions of these strategies with focused effort. Building AI products is fundamentally about creating trust interfaces, not just algorithmic performance. #startups #founders #growth #ai

𝐎𝐧𝐞 𝐥𝐞𝐬𝐬𝐨𝐧 𝐦𝐲 𝐰𝐨𝐫𝐤 𝐰𝐢𝐭𝐡 𝐚 𝐬𝐨𝐟𝐭𝐰𝐚𝐫𝐞 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 𝐭𝐞𝐚𝐦 𝐭𝐚𝐮𝐠𝐡𝐭 𝐦𝐞 𝐚𝐛𝐨𝐮𝐭 𝐔𝐒 𝐜𝐨𝐧𝐬𝐮𝐦𝐞𝐫𝐬: Convenience sounds like a win… But in reality—control builds the trust that scales. We were working to improve product adoption for a US-based platform. Most founders instinctively look at cutting clicks, shortening steps, making the onboarding as fast as possible. We did too — until real user patterns told a different story. 𝐈𝐧𝐬𝐭𝐞𝐚𝐝 𝐨𝐟 𝐫𝐞𝐝𝐮𝐜𝐢𝐧𝐠 𝐭𝐡𝐞 𝐣𝐨𝐮𝐫𝐧𝐞𝐲, 𝐰𝐞 𝐭𝐫𝐢𝐞𝐝 𝐬𝐨𝐦𝐞𝐭𝐡𝐢𝐧𝐠 𝐜𝐨𝐮𝐧𝐭𝐞𝐫𝐢𝐧𝐭𝐮𝐢𝐭𝐢𝐯𝐞: -Added more decision points -Let users customize their flow -Gave options to manually pick settings -instead of forcing defaults -Conversions went up. -Engagement improved. Most importantly, user trust deepened. You can design a sleek two-click journey. But if the user doesn’t feel in control, they hesitate. Especially in the US, where data privacy and digital autonomy are non-negotiable — transparency and control win. Some moments that made this obvious: People disable auto-fill just to type things in manually. They skip quick recommendations to compare on their own. Features that auto-execute without explicit consent? Often uninstalled. It’s not inefficiency. It’s digital self-preservation. A mindset of: “Don’t decide for me. Let me drive.” I’ve seen this mistake cost real money. One client rolled out an automation that quietly activated in the background. Instead of delighting users, it alienated 20% of them. Because the perception was: “You took control without asking.” Meanwhile, platforms that use clear prompts — “Are you sure?” “Review before submitting” Easy toggles and edits — those build long-term trust. That’s the real game. What I now recommend to every tech founder building for the US market: Don’t just optimize for frictionless onboarding. Optimize for visible control. Add micro-trust signals like “No hidden fees,” “You can edit this later,” and toggles that show choice. Make the user feel in charge at every key step. Trust isn’t built by speed. It’s built by respecting the user’s right to decide. If you’re a tech founder or product owner, stop assuming speed is everything. Start building systems that say: “You’re in control.” 𝐓𝐡𝐚𝐭’𝐬 𝐰𝐡𝐚𝐭 𝐜𝐫𝐞𝐚𝐭𝐞𝐬 𝐚𝐝𝐨𝐩𝐭𝐢𝐨𝐧 𝐭𝐡𝐚𝐭 𝐬𝐭𝐢𝐜𝐤𝐬. 𝐖𝐡𝐚𝐭’𝐬 𝐲𝐨𝐮𝐫 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞 𝐰𝐢𝐭𝐡 𝐭𝐡𝐢𝐬? 𝐋𝐞𝐭’𝐬 𝐝𝐢𝐬𝐜𝐮𝐬𝐬. #UserExperience #ProductDesign #TrustByDesign #TechForUSMarket #businesscoach #coachishleenkaur LinkedIn News LinkedIn News India LinkedIn for Small Business

In my experience, I've seen many teams relying heavily on automation, but neglecting the importance of manual testing. When I worked on a recent project, I realized that manual testing caught 30% more defects than automation alone. Manual testing is like proofreading a novel. You can use grammar and spell checkers to catch obvious errors, but only a human reader can truly understand the story's flow, tone, and emotional impact. Similarly, in software testing, automation can catch obvious bugs, but manual testing is essential for understanding the user experience, identifying subtle issues, and ensuring the software meets real-world needs. Manual testers are not just bug hunters; they're user advocates, ensuring the software is intuitive, usable, and provides value to end-users. By putting themselves in the user's shoes, manual testers can identify issues that automation might miss, like: - Is the workflow logical and intuitive? - Does the UI provide clear feedback and guidance? - How does the software handle unexpected user behavior? - Are the error messages clear and actionable? - Does the software's performance and responsiveness meet user expectations? By combining automation with manual testing, teams can ensure their software is both robust and user-friendly. Now, I'd love to hear from you: What percentage of defects do you estimate manual testing catches in your projects, compared to automation? Share your experiences in the comments below! #SoftwareTesting #ManualTesting #AutomationTesting #bugs

Last month, a startup CEO asked me: "Pramod, you're the automation guy. Can we just fire all manual testers?" My answer shocked him. I've built frameworks that run 10,000 tests overnight. I've reduced testing time from weeks to hours. But automation can't think like a frustrated user at 2 AM. It can't notice that "something feels off." It can't test scenarios nobody thought of. Companies save 8 LPA on QA salaries. Then spend 25 LPA fixing production disasters. Users don't follow your test scripts. They click random buttons. They enter weird data. They break things in creative ways. Currently, I use 80% automated regression tests. And 20% manual exploratory testing. This saved us from 3 critical UI bugs automation missed. Plus 2 usability issues that would've killed conversions. Automation is like a Ferrari - fast and powerful. Manual testing is like a detective - observant and intuitive. You need both. Companies cutting manual QA today will hire them back tomorrow. At double the salary. The best QA strategy isn't automation OR manual. It's automation AND manual. Who agrees?