Best Practices for Implementing Self-Service

🧭 ITIL 4 Guiding Principles in Action Rolling Out a Self-Service Password Reset Portal 🔐💻 Let’s see how all 7 guiding principles play out in this one initiative👇 🔹 1. Focus on Value 💡 Ask: “What problem are we solving?” 🎯 Users are frustrated with long wait times for password resets. ✅ We plan to build a self-service portal that reduces downtime and boosts productivity. Analogy: Like installing an ATM so customers don’t need to visit the bank just to withdraw money. 🔹 2. Start Where You Are 💡 Ask: “Do we already have tools or resources?” 🔍 We check and find that our Identity Management tool already supports password reset APIs. ✅ So we don’t buy a new product — we integrate what we already have. Analogy: Like realizing your phone already has GPS — no need to buy a separate navigation device. 🔹 3. Progress Iteratively with Feedback 💡 Ask: “What’s the smallest valuable thing we can launch first?” 🚀 We roll it out to 10% of users (like HR), collect feedback, fix bugs, and improve UI. 🔁 Then expand gradually to the rest of the organization. Analogy: Like testing a new dish with a few friends before serving it at a big party. 🔹 4. Collaborate and Promote Visibility 💡 Ask: “Who needs to be involved and informed?” 🤝 We bring in Service Desk (who handle reset calls), Security (to review risks), and HR (first users). 📣 We document updates on Teams and Confluence for all to follow. Analogy: Like assembling IKEA furniture — everyone follows the same manual, instead of guessing. 🔹 5. Think and Work Holistically 💡 Ask: “What’s the bigger picture?” 🌐 We ensure the portal links with Active Directory, audit logs, onboarding guides, and knowledge articles. ⚠️ The change touches multiple systems and support documents — not just a single app. Analogy: Like renovating a kitchen — you don’t just change the tiles; you consider plumbing, electricity, and storage too. 🔹 6. Keep It Simple and Practical 💡 Ask: “Can we remove friction for the user?” ✅ Instead of multi-layered approvals, we use 2FA for verification. 🧼 Clean design: “Forgot Password → Verify ID → Reset → Done” Analogy: Like designing an elevator with just two buttons — up and down — instead of 50 options. 🔹 7. Optimize and Automate 💡 Ask: “Can we make this smarter over time?” 🤖 Add triggers like offering a chatbot reset option after failed login attempts. 📊 Monitor usage data to refine the process and user experience. Analogy: Like using a smart thermostat that learns your habits and adjusts automatically. ✅ Outcome: 📉 60% drop in password-related tickets 🙌 Happier users with less downtime 🕒 Service Desk now has more time to handle complex issues This is ITIL in real life — practical, agile, and always adding value. Whether you're in Ops, Dev, or Service Management, these principles scale. #ITIL4 #ITSM #GuidingPrinciples #DigitalTransformation #ServiceManagement #ValueCreation #Automation #ProcessImprovement

Everyone wants AI in ServiceNow right now, but very, very few organizations are actually ready for it. We recently worked with a global real estate organization that thought their biggest challenge was “better AI”, but what they really had was a foundational problem. Search wasn’t working the way users expected. Self-service adoption was low. Knowledge articles and catalog items were hard to find. And the terminology inside the platform wasn’t even consistent. So users did what users always do when systems fail them: they opened tickets. Before jumping straight to shiny AI features, we stepped back and assessed the current state. AI doesn’t fix broken fundamentals at all. In fact, it amplifies them. Our approach was deliberate: 🞄 Assess what’s actually happening in the platform 🞄 Deliver quick wins to prove value 🞄 And build a roadmap that aligned AI capabilities with real operational outcomes We focused first on improving search relevance and self-service. Prioritizing Now Assist Q&A results. Making sure the right knowledge surfaced at the right time. Reducing unnecessary incidents by helping users help themselves. But the real value? The real value came from the roadmap. Instead of deploying AI in isolation, we defined a phased strategy across ITSM- Incident, Request, Knowledge, Virtual Agent, Change, and Reporting- with governance and metrics attached. Our goal was clear: a 20% increase in self-service adoption. Successful AI adoption requires a disciplined approach, grounded in how people really use the platform. AI is powerful, but only when it’s built on a solid foundation. Only then can real work, and real results, happen. 

Most SaaS companies assume self-serve is a product decision—clean up the UI, remove a few steps, add a “get started” button, and boom, self-serve. But that’s not even close. The biggest blocker we’ve seen (both in our own product and across the SaaS space) is onboarding. I’m not just talking about walkthroughs or tooltips. I mean the entire experience of helping someone go from "What does this do?" to "This solves my problem"—without ever talking to them. The reality is, most complex tools aren’t gated because the founders want you to talk to a salesperson. They’re gated because getting started is scary. Take Salesforce. It’s technically self-serve, right? You sign up, poke around, and start setting up your CRM. But unless you know what you’re doing, it’s absolutely mind-boggling. That’s where most teams building self-serve products miss the mark. Sure, you can blame product, engineering, or design. But the real issue is deeper. The lift required to make a complex product feel intuitive is massive. It demands the entire company to align around a different kind of user journey. You need to distill workflows, bundle outcomes, rewire onboarding, and rebuild parts of the business around the idea that users won’t talk to a human. Ever. It’s marketing, product, support, solutions—everyone building for the assumption that the user is flying solo. Cracking that code isn’t easy. That’s why I admire true self-serve products so much. What’s one product that nailed the self-serve experience in your eyes? Always looking to learn from the best.

Build things with self-service in mind: As technologists, we should constantly design with self-service in mind. When you build systems that empower others — your customers, your product teams, even your future self — you naturally move toward a more loosely coupled architecture. You stop creating bottlenecks. You stop being the gatekeeper. Instead, you create tools, APIs, and flows that let people get things done without waiting on you. And here’s the key part: you don’t need a full-blown self-service UI on day one. If your backend is designed with self-service capability as a principle, you can start with something extremely simple. Sometimes the first version of “self-service” is just a CLI tool that wraps your core APIs. Instead of making code changes, deploying, and testing every time someone needs a configuration update, you can run a single command and do it in minutes. That’s already a huge win. Then, when the timing is right, that CLI tool can evolve into a proper graphical UI without requiring you to re-architect the entire backend. The platform is already built for it. The contracts are clean. The boundaries are respected. You’re just adding a new layer on top. This is the essence of a minimalist technology stack. Fewer dependencies. Clear ownership. Simple interfaces. When you design for self-service, you’re indirectly designing for scale, resilience, and velocity. And the funny thing is, it also reduces the operational burden on your own team. You free up your engineers to focus on higher-leverage work — like exploring new ideas, building proofs of concept, and pushing innovation instead of constantly unblocking others. Self-service isn’t just a feature. It’s an architectural mindset. And once you adopt it, everything else gets simpler. #softwareengineering #coding

🤖Your customers don’t want to chat with a robot. What they really want is to get their questions answered and their issues resolved. ❌Yet, the majority of self-service tools are just not cutting it. The recent Gartner survey shows the reality: 1. 43% of customers couldn’t find content relevant to their issue. 2. 45% of customers felt that the company didn’t understand what they were trying to do. 3. 14% of customer service issues are fully resolved through self-service. We need to do better. If you’re serious about improving self-service resolutions, here’s where to start: 1. Let your self-service tool tap securely into your knowledge base, policies, and compliance systems. This will enable your customers to search and retrieve relevant content. With Gen AI, you can summarize content and deliver answers, not just links to knowledge articles. 2. Connect your self-service tool to backend systems to truly understand the customer’s issue. For instance, if a customer wants to troubleshoot their smartwatch, your tool should access at least five systems: - Your CRM to check recent products ordered by this customer - Your knowledge base to pull up troubleshooting articles - A warranty system to see if the customer has an active warranty - An inventory system to check if there’s a new device for replacement - A corporate calendar in case the customer prefers to visit a store 3. Turn complex processes into step-by-step workflows that guide customers through resolutions. AI can help you generate draft workflows based on your unstructured data. Review and release your workflows to ensure compliance. What are your thoughts on integrating backend systems into your self-service tool? Any successes or failures? Let’s chat. 👇

When 10% of support tickets come from customers trying to modify orders post-purchase, you're looking at a broken system. I've seen this drain resources across hundreds of e-commerce stores. Here's how to fix it: 1️⃣ Self-service order modification Customers shouldn’t need to contact support for basic changes. So, let them modify their orders within a set window after purchase. I’m talking about… - Quantity adjustments - Shipping address updates - Product options like gift wrapping Amazon has mastered this approach— Their 'edit order' option lets customers change everything from shipping speed to delivery address, as long as the product hasn't shipped yet. This eliminates unnecessary cancellations and reorders. 2️⃣ Clearer communication Before placing an order, your customers need complete visibility. ASOS knows this, so they show all relevant order details: - Quantities - Total costs - Product info - Itemized billing - Shipping address - Expected delivery dates Your FAQs should clearly explain… - The self-service modification process - Which elements can be modified - Timeframes for order changes - How to track packages Better yet, integrate a chatbot that guides customers through ordering questions before they become support tickets. 3️⃣ Better order confirmation and review process After order placement, let customers see the complete order summary on a dedicated page with… - An itemized list with clear product images - Shipping and billing addresses - Total cost including taxes - Shipping method It’s also helpful to send confirmation emails immediately, including specific details about… - What can be modified - When changes are possible - How to make those changes 4️⃣ Streamlined internal processes Your systems *must* work as one: - Shipping software - E-commerce platform - Order Management System (OMS) - Warehouse Management System (WMS) When these systems communicate seamlessly, you create a smaller window for order modifications. But technology alone isn’t enough. Your team needs bulletproof processes for… - Manual change requests - Policy enforcement - Issue escalations 5️⃣ Data analysis and continuous improvement Every order modification request tells a story. So, track patterns in what customers are changing post-purchase (and how often): - Shipping addresses - Shipping methods - Product details We’ve found these often reveal deeper issues in the purchase journey. 💡 Remember: Every time a customer needs to modify their order, it's not just a support ticket. It's a signal that your system has a gap. And those signals? They're showing you exactly where to focus next.

Using data shouldn’t suck. But for most teams, it still does. (Especially when it comes to 𝘴𝘦𝘭𝘧-𝘴𝘦𝘳𝘷𝘪𝘤𝘦 𝘉𝘐) After working on multiple self-service initiatives across clients, I’ve seen one thing clearly: Most self-service environments are 𝘯𝘰𝘵 set up for success. Looker can be a fantastic tool when done right. But enabling true self-service takes more than spinning up a few Explores. It takes semantic precision. End-user empathy. And ruthless cleanup. Here are 4 ways to build a self-service BI layer that works across any BI tool: 1. Label with care 2. Train your users 3. Organize by business context 4. Clean up your mess Ultimately, BI should empower, not confuse. ♻️ Share this to help someone in your network. Follow for weekly insights on BI, data strategy, and analytics that drive real business outcomes. P.S. Would you add anything else?

Self-Service Analytics Without the Graveyard: Designing for Trust Part 1 of a series on rolling out self-service analytics for the enterprise. Every data leader has visited the same graveyard: self-service rollouts that launch with a town hall and a demo, then six months later decay to the traditional methods Planning self-service rollout, the question wasn't "How do we give everyone access to data?" but "How do we give them data they can trust?" That reframe — trust, not access — changed almost every decision we made. The two failure modes The first is the wide-open buffet: hand people a BI tool, point it at the warehouse, and turn them loose. Predictably, five teams compute "active users" five ways, three are wrong, and people stop trusting the numbers. The second is the fortified bunker. Burned by the buffet, you overcorrect: every metric needs certification, every dashboard a review. Adoption craters because "self-service" feels like filing a request and waiting. Three design tensions 1. What belongs in the semantic layer. The temptation is to model everything. We didn't, only the heavily used objects: revenue, retention, core engagement. The long tail stayed in the warehouse as raw, documented tables. The semantic layer is for agreed truth; the warehouse is for exploration. Conflating them is how you get a 4,000-line YAML file nobody dares touch. 2. Verified queries. Queries an engineer has vetted for accuracy tell the engine which to use, and solve for performance and cost. Without them it guesses, takes the long route, and drives up latency and spend — and it's not one-and-done, since the data objects keep changing. 3. Governance that helps, not gates. Every data product gets a tier — certified, community, or experimental — shown next to the result. Query an experimental table and you get the data plus a plain warning: "This isn't certified. Don't put it on a board deck." It sounds obvious, but it's bought us the most trust: tell people the confidence level and they decide well. The unglamorous work that made it work What's really making this succeed isn't any of the above. It's the metadata: real column descriptions, a current glossary, documented joins, and "ARR" meaning the same thing in three schemas. The LLM was never the bottleneck; nobody had ever written down what event type = migration means. Unglamorous and hard to staff — and the only thing that turns self-service from a graveyard into something people use. If I were starting over, I'd spend the first quarter doing nothing visible — no tool selection, no town halls. Just metadata, governance tiers, and a short list of certified metrics. The platform on top of that comes together in weeks; on top of an unprepared substrate, it's the graveyard.