Avoiding Unintended Consequences in Service Design

✂️ How To Map Unintended Consequences of UX Decisions (https://lnkd.in/dprq_aGc), with practical techniques to visualize, map and start planning for unintended consequences of design decisions — with systems thinking, impact ripples, iceberg visuals and feedback loops. By Martin Tomitsch and Justin Farrugia. 🤔 Not every design outcome is predictable and linear. ✅ Small changes can set large ripple effects in motion. ✅ Users don’t act in isolation; they react to feedback loops. ✅ Immediate metrics (e.g. clicks) often mask long-term impact. 🚫 We often focus on UX flows → but overlook causality, ripples. ✅ Systems Maps visualize relationships and consequences. ✅ We study direct and indirect effects of a suggested change. ✅ Quadrant Matrix → We map changes on Impact vs. Repetition. ✅ Impact Ripple → Direct impact, Indirect Impact, Big Picture. ✅ Iceberg Model → Events, Patterns, Structures, Mental Model. No design decision exists in isolation. Often we try to use linear user journey maps to understand how people use our product or go through specific flows. We measure the impact of A/B tests to see if we achieve a desired outcome and move the needle. We track conversion, clicks, engagement. In other words, we track metrics that often hide the complexities of user interactions and relationships between features and flows in our products. Complex systems often have conflicting loops — a feature that drives short-term retention might drive long-term churn or abandonment. Often these effects are delayed, invisible and appear to be highly unlikely at first. So before focusing on fine details of a feature, it's always a good idea to sit down and explore direct and indirect impact of the changes — for different user profiles, and the different workflows that users apply daily. A great reminder that as designers we are often so focused on fine little details too early — mostly to outperform the competition in some way. But we often forget that our product must excel in user's workflows with a few critical systems, dozens of other apps and hundreds of other tabs. --- ✤ Useful Toolkits and Books: Designing Tomorrow, by Martin Tomitsch, Steve Baty https://lnkd.in/dmXEZREr Thinking in Systems: A Primer, by Donella Meadows https://lnkd.in/dXbm5EEA Good Services: How to Design Services that Work, by Louise Downe https://lnkd.in/d5SigzvX The Great Mental Models, by Rhiannon Beaubien https://lnkd.in/dnT_GtDT Useful Books on Systems Thinking, by James Pomeroy https://lnkd.in/dH7d9exZ #ux #design

Long ago in Delhi, a British officer put up a sign: “WE PAY FOR EVERY DEAD COBRA.” Soon, people lined up with snakes. Then something unexpected happened, they started breeding cobras to earn more money. When the plan was stopped, the breeders released their snakes. The result? Even more cobras than before. In hospitality, the same principle applies. Imagine a hotel rewarding staff for every positive guest review. At first, it seems smart but soon, some team members focus only on getting reviews, encouraging guests to leave quick feedback rather than delivering genuinely thoughtful service. When the incentive is removed, the focus on authentic service has diminished, and overall guest satisfaction may drop. The lesson: short-term incentives can backfire. Building a culture of genuine service, long-term habits, and intrinsic motivation creates results that last without “breeding more cobras.”

Is every new feature just another bundle of risks waiting to be discovered? Every time we add functionality, we potentially introduce performance bottlenecks, security holes, or usability quirks. Risk-based thinking applies here, too—during feature planning, ask what could go wrong and who might be affected. Identify the most critical components and focus your testing energy on them. This approach helps you plan test scenarios that mirror real user behaviours and stress conditions. By acknowledging risk early, your team can incorporate mitigations and design decisions that reduce surprises. Ultimately, risk is inevitable, but managing it wisely can turn new features from potential minefields into well-tested value additions.

Well-designed cross-functional processes are powerful. They create customer experiences that are effortless for the customer and more efficient for the organization. Here's a story that illustrates this point. A colleague of mine visited the contact center for a well-known health insurance company and relayed this experience to me. While she was meeting with team members, she saw job aids referring to “building empathy” and delivering “apologies with heart.” The quality assurance (QA) form measured employees on how well they helped customers manage their intense emotions over delayed claims. The training content emphasized how to explain complicated claims processes. When she met with the contact center director, she asked, “Why so much time and energy on training reps to manage customers who are disappointed… by you? Why not just fix the claim issue?” He sighed. “It’s not that easy. The claims department has their way of doing things. We’ve tried to meet with them over this issue a few times, but the message is clear—‘stay on your side of the fence.’ We do our best, but customers express frustration every day. We can’t magically make customers okay with it.” This gap between what customers want and what is being delivered—and I suspect you may have similar stories—is all too familiar in many organizations. Customer-centric organizations, however, spend proportionally more time designing processes and proportionally less time getting better at appeasing unhappy customers. They devote their attention to eliminating what makes customers unhappy in the first place. Of course, glitches will still happen, and the processes you use to resolve those issues are essential. Effective complaint resolution will always be part of your CX portfolio. But that shouldn’t be the main focus. The challenge? Without deliberate intervention, departments don’t naturally work across functional lines. The marketing team focuses on messaging and response rates. The product management team is occupied with product design and development. Billing concentrates on revenue and collections. Each team fixates on being the best they can be within the boundaries of their department. Every department can agree that designing processes and technology with the customer in mind makes sense. Even so, being customer-focused within a silo doesn’t fix the most exasperating barriers to good experiences. Great experiences happen by design through cross-department collaboration. They are shaped with a clear-eyed view of the customer as they traverse through the work done by marketing, product management, billing, and the contact center. That work must be coordinated and seamless for the trip to feel effortless, satisfying, and yes, sometimes even WOW. And to create that collaboration, your organization must have high-level sponsorship. Senior leaders must define a common vision and goals, and hold all accountable to pursue them.

Things I’d avoid if I wanted to be a Service Designer in 2026 1. Thinking service design = better UX Spending time on journeys, personas, interfaces. Ignoring what sits behind them. → Policy → Operations → Funding → Delivery That’s where services actually live. 2. Designing without understanding constraints Creating ideal experiences with no awareness of: → Budget limits → Legacy systems → Governance rules → Procurement cycles → Staffing capacity → Looks great in decks → Fails in reality 3. Treating users as the only priority Focusing only on user needs. Ignoring: → Frontline staff → Internal teams → External suppliers → Decision-makers Services are negotiated systems, not user-only products. 4. Improving touchpoints instead of fixing flows Redesigning forms, apps, single interactions. Not asking: → What happens before? → What happens after? → Where does it break? → Who owns it? → Surface improves → System stays broken 5. Avoiding system-level decisions Staying in safe design territory. Not engaging with: → Trade-offs → Incentives → Power structures → Policy implications → That’s where real impact sits 6. Simplifying too early Turning complex systems into clean diagrams. Removing: → Conflicts → Dependencies → Ambiguity → Easier to explain → Impossible to deliver That’s the trap. → Product thinking optimises experiences → Service design reshapes systems And in 2026: → Execution will be automated → System thinking won’t be — I’ve been trying to make sense of the future of Service and Product properly through system thinking and proper AI usage. If you’re thinking about it too, I’m writing more in The Curious Society. Join my Newsletter: ⤷ https://lnkd.in/ehy-HwXW Volume 2: In a world of robots, Be a Human! Service in the Real World: How systems differ across Public, Private, and Market Models Date released: 15/05/2026

The outcome of design is change. Strategic designers are intentional about change and reduce unintended consequences. But organizations typically focus on problem-solving, which creates a sense of control for practitioners; they can determine what the problem is, so the next step is to solve the problem, find a solution. Problem-solving appears to be practical, doable, and efficient. But problem reductionism leads to discrete solutions that generate unintentional change and unintended consequences (e.g., harm to secondary stakeholders, new problems, contamination, conflicts, etc.). Design problems are wicked and complex. Therefore, designers make proposals rather than solving problems. A proposal is a conjecture that may or may not work as expected in context. Yet, it is a conjecture that carries integrated and systemic intentionality. Strategic designers develop expertise to understand broad situations with high uncertainties and make decisions with incomplete information, combining evidence and intuition.

Order saved. Payment failed. No alert. That's distributed partial failure. And it's silent. In a monolith, you wrap everything in one transaction. It commits or rolls back. The database handles the rest. Add a second service with its own database and that guarantee disappears. ACID only holds within one database. Cross-service consistency is your problem to solve. Here's how to solve it: 𝗧𝗵𝗲 𝗖𝗼𝗻𝘀𝘁𝗿𝗮𝗶𝗻𝘁 Each service owns its database. One service, one database, one transaction. The moment Order Service commits and Payment Service fails, you have partial completion with no automatic rollback and no exception thrown. 𝗪𝗵𝘆 𝗧𝘄𝗼-𝗣𝗵𝗮𝘀𝗲 𝗖𝗼𝗺𝗺𝗶𝘁 𝗙𝗮𝗶𝗹𝘀 2PC coordinates a prepare and commit phase across all participants. In practice it adds tight coupling, blocks every resource until all participants vote, and collapses when any node is slow or unavailable. Cloud-native systems running mixed databases, message brokers, and third-party APIs can't use it cleanly. ❌ Don't add 2PC hoping a distributed system will behave like a monolith. 𝗧𝗵𝗲 𝗢𝘂𝘁𝗯𝗼𝘅 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 Write your business data and an outbox event in the same local transaction. A background relay reads the outbox table and publishes to the broker. If the broker is down, the relay retries. If the relay crashes, it picks up where it stopped. → Single DB transaction: order row + outbox row, atomic → Relay polls for unsent records, publishes, marks as sent on confirmation → Eliminates the "database updated but event lost" problem → Consumers must be idempotent — delivery is at-least-once ❌ Don't write to the DB and publish to the broker as two separate steps. One will fail eventually. 𝗧𝗵𝗲 𝗦𝗮𝗴𝗮 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 A saga breaks a cross-service workflow into a sequence of local transactions. Each step commits locally and emits an event or command to trigger the next. If a later step fails, compensating actions undo the earlier work. → Order Created → Payment Reserved → Inventory Reserved → Confirmation Sent → Inventory fails: trigger Refund Payment, then Cancel Order → Compensation is business logic, not a database rollback → Orchestrated via a coordinator, or choreographed through events ❌ Don't build a saga without mapping every failure path. Stuck partial states with no recovery path are worse than the original problem. 𝗘𝘃𝗲𝗻𝘁𝘂𝗮𝗹 𝗖𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝘆 Services will temporarily disagree while messages are in flight. Design for it. → Show users a "pending" or "processing" state while the system converges → Build retries, deduplication, and idempotent consumers from day one → Use explicit status models: pending, processing, failed, compensated, completed → Monitor event queue depth and processing lag, not just uptime Design for converging state, not instant state. Get my free .NET Backend Blueprint 👇 https://lnkd.in/gnQhKDDC

I made a mistake early in my career that cost a client three weeks and a significant amount of money. I specified a cooling system based on the maximum design load without fully modeling the part-load conditions the facility would actually operate under for 90 percent of its life. The system worked perfectly at full load. But at partial load, which is where every datacenter spends most of its time during ramp-up, the cooling equipment was oversized and cycling constantly. Compressors short-cycling. Valves hunting. Controls oscillating because the system could not modulate smoothly at low loads. The equipment was not wrong. The design approach was wrong. I had optimized for the worst-case scenario and ignored the scenario that actually mattered most. That experience changed how I approach every project. Now we model facility performance across the full range of expected operating conditions, not just the peak. We select equipment and design controls specifically for smooth operation at 30, 50, and 70 percent load because that is where the facility will live for months or years before it reaches full capacity. The lesson cost me. But it has saved every client since. Is your cooling system designed for peak load or for the load profile it will actually see during its first two years of operation?

𝐌𝐨𝐬𝐭 𝐛𝐞𝐠𝐢𝐧𝐧𝐞𝐫𝐬 𝐝𝐨 𝐧𝐨𝐭 𝐟𝐚𝐢𝐥 𝐢𝐧 𝐬𝐲𝐬𝐭𝐞𝐦 𝐝𝐞𝐬𝐢𝐠𝐧 𝐛𝐞𝐜𝐚𝐮𝐬𝐞 𝐭𝐡𝐞𝐲 𝐥𝐚𝐜𝐤 𝐢𝐧𝐭𝐞𝐥𝐥𝐢𝐠𝐞𝐧𝐜𝐞. They fail because they miss the invisible cracks early. And those small mistakes? They become expensive problems later. → 𝐋𝐞𝐭’𝐬 𝐝𝐞𝐜𝐨𝐝𝐞 𝐭𝐡𝐞 𝐛𝐞𝐠𝐢𝐧𝐧𝐞𝐫 𝐦𝐢𝐬𝐭𝐚𝐤𝐞𝐬 𝐭𝐡𝐚𝐭 𝐪𝐮𝐢𝐞𝐭𝐥𝐲 𝐛𝐫𝐞𝐚𝐤 𝐠𝐫𝐞𝐚𝐭 𝐬𝐲𝐬𝐭𝐞𝐦𝐬 • Starting without clear requirements Jumping into coding too early creates confusion, conflicting decisions, and incomplete features. • Overengineering solutions Adding too much complexity at the beginning wastes resources and increases long term maintenance effort. • Ignoring scalability early Designing only for today can make future growth painful, costly, and difficult to manage. • Neglecting fault tolerance Not planning for failure means node crashes or network issues can quickly turn into downtime and poor user experience. • Skipping caching strategies Without caching, systems become slower, database load increases, and performance starts to drop under traffic. • Poor database design Choosing the wrong database type or ignoring indexing often leads to bottlenecks and inefficient queries. • Ignoring security Weak authentication, poor authorization, and missing encryption leave systems exposed to vulnerabilities and data breaches. • Not monitoring and logging Without visibility into errors, performance, and traffic spikes, troubleshooting and optimization become much harder. • Hardcoding configurations Embedding environment specific details in code creates deployment pain and reduces flexibility. • Not testing at scale Testing only on small datasets hides concurrency issues and real world performance failures. → Great system design is not about drawing complex diagrams It is about making clear, practical, and future ready decisions. The earlier you avoid these mistakes, the stronger your systems become. Follow Umair Ahmad for more insights

You don't need a design degree or a year-long project to start thinking more human-centeredly. Here are practical shifts you can make in how you approach your work. Observe Before You Solve Next time someone brings you a problem, resist the urge to immediately propose solutions. Spend time watching how the current system actually works. What you think is happening and what's actually happening are often different things. Talk to People Who Experience the Problem Differently Than You Do If you're designing for patients, talk to night shift staff. If you're solving for clinicians, talk to environmental services. Different perspectives reveal different problems - and often, better solutions. Ask "What Are You Trying to Accomplish?" Not "What Do You Want?" People often request specific solutions ("I need a bigger workspace") when what they actually need is something else entirely (uninterrupted focus time). Get underneath the request to the underlying need. Test Assumptions in Real Conditions, Not Ideal Ones Don't test your new process on a Tuesday afternoon when everything is running smoothly. Test it at 2am when staffing is thin. Test it when someone just got difficult news. That's when you learn if it actually works. Look for Workarounds When people create their own solutions - sticky notes on monitors, makeshift storage, unofficial communication channels - they're telling you something important about what the official system isn't providing. Workarounds are design insights. Spend Time in Transition Moments The moments between activities often reveal more than the activities themselves. Watch handoffs between shifts. Observe what happens between appointments. See how people navigate from parking to check-in. That's where friction lives. Ask "Who Else Is Affected by This?" Every change ripples. Before implementing a solution, map who else it touches - staff in different roles, patients at different stages, families, support services. Design for the ecosystem, not just the primary user. Make Your Assumptions Explicit and Testable Write down what you believe is true about the problem and the solution. Then actively look for evidence that you're wrong. Being wrong early and small is much better than being wrong late and large. Create Small Tests Before Big Commitments Pilot with one team, one unit, one process before scaling. Learn what you didn't anticipate. Iterate based on what you learn. Small experiments reduce risk and improve outcomes. Measure What Happens to Humans, Not Just to Systems Yes, track efficiency metrics. But also track: Can staff actually take breaks? Do patients feel heard? Are handoffs smoother? Did this create more capacity for the interactions that matter? If you're only measuring operational efficiency, you're missing half the story.