I always ask myself if we make the right solutions for the end user at our customers. An article about UX on LinkedIn and the responses caught my attention, the reason why I am writing this blog.

You can find the article in German (Deutsch) here: Der False-Consensus-Effekt oder: Du bist nicht der User (edcontent.de) Free translated as The false consensus effect: you are not a user.

In software development, one of the most common pitfalls is forgetting that we are not the end-user. This disconnect often leads to building solutions that don’t fully address the real-world needs of users, resulting in inefficient or poorly adopted software.

The infamous “swing-tree” parodies illustrate this perfectly. In these cartoons, the process of building a simple swing reflects how different people interpret the same request. By the time the swing is built, the final product looks nothing like what the user needed or expected. Our  perspective may be focused on code structure, technical feasibility, or optimization. While these factors are important, they often don’t align with the practical, day-to-day challenges of the actual users. We might build a technically perfect swing with advanced features, but if it’s uncomfortable to sit on or doesn’t hang well from the tree, it’s ultimately a failure for the user.

When we rely only on our understanding of the problem or make assumptions about how a feature should work, it increases the risk of delivering something that misses the mark. This is why collaboration with users throughout the development process is crucial. By continuously gathering feedback and engaging with real-world scenarios, developers can ensure that what they’re building is genuinely useful and aligned with users’ expectations.

How can we do it together better?

As a consultant with focus on the end-user:

• Conduct user interviews and surveys: Direct communication with end-users is essential. Consultants should conduct one-on-one interviews, surveys, or focus groups to gather firsthand information about user pain points, goals, and daily workflows. These interactions help uncover specific needs that may not be obvious from a high-level perspective and allow consultants to ask follow-up questions that dive deeper into user expectations.
• Observe users in their natural environment: Shadowing or observing users as they perform their tasks provides valuable insights into how they interact with existing systems and the challenges they face. This helps consultants understand real-world scenarios, uncover hidden issues, and identify inefficiencies that users themselves may not articulate. Seeing how users actually work ensures the software is designed with their real habits in mind.
• create and analyze user personas: User personas represent different types of end-users, including their goals, frustrations, and day-to-day activities. By creating detailed personas, consultants can tailor the software solution to various user needs rather than relying on generic assumptions. Personas help focus the development on specific groups and ensure the software is both relevant and useful to its target audience.
• Facilitate prototyping and usability testing: Prototypes and mockups allow end-users to interact with early versions of the software and provide feedback. By facilitating usability testing sessions, consultants can gather real-time feedback on design choices and functionality. This iterative process ensures that user feedback is incorporated before final development, minimizing the risk of developing software that doesn’t meet user needs.

As a fusion team, developers and consultants together:

• Create detailed user stories: User stories are concise descriptions of end-user requirements from their perspective. A well-crafted user story typically follows the format: “As a [user role], I want [a specific feature] so that [desired outcome].” By clearly defining the “who,” “what,” and “why,” consultants can convey the end-users’ goals and needs in a way that developers can easily understand and translate into actionable tasks. This helps developers grasp the practical use cases behind each feature request.
• Develop functional and non-functional requirements: Consultants should break down end-user needs into clear, detailed functional requirements (what the system should do) and non-functional requirements (how the system should perform, e.g., security, performance). Functional requirements outline the specific features, while non-functional requirements ensure that developers consider performance, scalability, and usability. These detailed specifications help developers understand not just what to build, but also how the software should behave under different conditions.
• Use wireframes and visual prototypes: Visual aids like wireframes, mockups, or prototypes can help bridge the communication gap between consultants and developers. These tools provide a visual representation of how the end-user expects the software to look and function. By walking developers through these visuals, consultants can give concrete examples of what the user interface (UI) should entail, helping developers understand the user flow and user experience (UX) requirements more clearly.
• Foster open communication with developer: Regular communication between consultants and developers is crucial for ensuring alignment. Consultants should act as intermediaries by hosting joint meetings, demos, or workshops where developers can ask questions and clarify user needs in real time. Encouraging open dialogue ensures that any ambiguities in user requirements are addressed early, reducing misunderstandings during development.

The end-user approach:

• Engage users early and often: It’s critical to involve end-users from the very beginning of the software development process. By conducting discovery workshops, interviews, and surveys during the requirements gathering phase, consultants and developers can understand user pain points and expectations before development begins. Continuously seeking feedback at every stage ensures that end-user input shapes the final product.
• Leverage prototyping and usability testing: Prototyping tools and wireframes allow consultants and developers to create mockups or low-fidelity versions of the software. End-users can then interact with these prototypes in usability testing sessions. This approach provides real-time feedback on user interface design, functionality, and user experience. By testing prototypes with actual users, developers can make improvements iteratively based on user insights, rather than waiting until the software is fully built.
• Conduct beta testing and pilot programs: After developing an initial version of the software, releasing it to a small group of users for beta testing or through a pilot program is an effective way to gather feedback in real-world conditions. During this phase, users can report bugs, suggest improvements, and provide feedback on how the software functions in their day-to-day workflows. This approach helps ensure that the software is refined before wider deployment.
• Use feedback tools and surveys post-launch:Once the software is launched, consultants and developers should implement feedback tools like in-app surveys, polls, or analytics to gather continuous user input. Monitoring how users engage with the software through usage data and soliciting feedback through short surveys will provide insights into what’s working well and where improvements are needed. Additionally, user forums or feedback channels can facilitate ongoing dialogue.
• Facilitate regular check-ins and feedback loops: Maintaining an open line of communication with end-users is key to collecting ongoing feedback. Consultants and developers should schedule regular check-ins, such as meetings, webinars, or feedback sessions, to review how the software is performing from the user’s perspective. This provides a structured opportunity for users to voice concerns or suggest enhancements based on their evolving needs.

My thoughts on this

By combining these methods, consultants and developers can ensure that they not only collect accurate feedback but also incorporate it effectively into the development process, leading to a product that resonates with its end-users.

Ultimately, software is a tool created to solve problems for people, not us as consultants or developers. By recognizing that the end-user’s perspective is different and just as important as the technical perspective, we can avoid building the wrong software. Involving users early and often ensures that the final product truly meets their needs and is not just a reflection of the consultant’s or developer’s vision.