User-centric feature design

When I started my career in software development, I was fortunate to work on a variety of projects and interact directly with clients. My responsibilities included gathering requirements, designing features, and implementing them. Part of our process involved conducting recurring demos with clients to gather feedback and iterate on our designs. This approach was crucial in ensuring that we were building the right features and meeting the clients’ needs.

It quickly became apparent that the most successful features were those designed with the user in mind. This is why I believe that user-centric feature design is essential for building successful software products. I’ve carried these lessons with me as I’ve moved to larger companies, where users are often less accessible, and engineers tend to focus more on technical implementation rather than user experience.

Here, I want to share the framework I use when planning a new feature and the strategies to elicit feedback to ensure that what we build is truly what the user needs. This approach not only helps in creating features that resonate with users but also fosters a more collaborative and iterative development process.

• Identify the problem
• Define User Stories
• Map the User Journey
• Design the Solution
• Gather Feedback and Iterate

graph LR
    A[Identify the Problem] --> B[Define User Stories]
    B --> C[Map the User Journey]
    C --> D[Design the Solution]
    D --> E[Gather Feedback and Iterate]
    E --> A

Identify the problem

The first step in designing a user-centric feature is to identify the problem you’re trying to solve. This could be a pain point for users, a feature gap in your product, or a new opportunity to enhance the user experience. Clearly defining the problem ensures that the feature you build addresses a real need and provides value to your users.

To start, I like to ask these key questions:

• What problem are we trying to solve? (Identifies the pain point)
• Who is experiencing this problem? (Identifies the target user)
• How does this problem impact the user’s workflow? (Understands the context)

Define User Stories

Once you have identified the problem, the next step is to define user stories that capture the user’s perspective. User stories are short, simple descriptions of a feature told from the perspective of the person who desires the new capability, usually a user or customer. They typically follow the format:

“As a [type of user], I want [some goal] so that [some reason].”

For example:

“As a new user, I want to be able to sign up with my email address so that I can access the platform.”

User stories help maintain focus on the user’s needs and motivations, providing a clear understanding of what the feature should accomplish.

Map the User Journey

Mapping the user journey involves visualizing the steps a user takes to accomplish a specific task or goal within your product. This process helps you understand the user’s interactions, emotions, and pain points throughout their experience. By mapping the user journey, you can identify opportunities to streamline the user flow, remove friction points, and enhance the overall user experience.

I like to create user journey maps that include the following elements:

• Stages: The key phases the user goes through to complete their goal.
• Actions: The specific actions the user takes at each stage.
• Emotions: How the user feels during each stage and action.
• Pain Points: The challenges or frustrations the user encounters.
• Opportunities: Potential improvements to enhance the user experience.

Design the Solution

With a clear understanding of the problem, user stories, and user journey, you can begin designing the solution. As a backend engineer, I recognize my limitations in understanding the frontend design intricacies. However, having at least a basic understanding of the entire stack is crucial to plan the feature effectively. This involves collaborating with frontend developers, designers, and product managers to ensure that the solution aligns with the user’s needs and the overall product vision. It also means educating myself on frontend best practices and new technologies.

I focus on several key aspects:

• User Interaction with the Frontend: Even though my main focus is on the backend, understanding how users will interact with the frontend helps me design APIs that support the required functionality efficiently. For example: if a user is interacting with a form, but they need to be able to save their progress and come back later, I need to design the backend to support this feature.

• API Design: Designing a clear and efficient API is critical for enabling communication between the frontend and backend. The protocol of choice depends on the project requirements, but I always aim for simplicity, consistency, and ease of use. In most cases, RESTful APIs are the way to go, and I follow resource-oriented design principles to achieve this.

• Data Model: It is the backbone of any application. It is important to design a data model that is optimized for performance and scalability while ensuring data integrity and consistency. This includes defining database schemas, objects, relationships (when applicable), and constraints.

• Security: This should always be a part of the design process. I consider aspects like authentication, authorization, data encryption, and secure communication protocols to protect user data and prevent unauthorized access. It’s also important to ensure that we are not storing more identifiable information than necessary. I follow two simple rules: least-privilege access and, when it comes to PII, only store what is absolutely necessary.

• Scalability and Performance: Planning this from the outset helps avoid issues as the application grows. This includes considering aspects like load balancing, caching, and efficient query design. We also need to consider loose coupling between services to make it easier to modify and scale individual components.

Gather Feedback and Iterate

Once the feature is designed and implemented, it’s essential to gather feedback from users to validate that the solution meets their needs. This feedback can come from various sources, such as usability testing, surveys, analytics data, and direct user interviews.

I’ve found that involving users early in the process and iterating based on their feedback leads to better outcomes. It’s important to be open to criticism and willing to make changes to improve the user experience continually. But it is equally important to understand that one user’s feedback might not represent the majority of users, so it’s essential to look for patterns and trends in the feedback.

If the feedback received indicates that the feature needs improvement, this is when the iterative process comes into play. We go back to the design phase, make the necessary adjustments, and repeat the feedback loop until we achieve a solution that resonates with users.

Building a Platform, Not Just a Product

Another approach I strive to adopt is to aim to build platforms rather than just products. This means designing features that are broad and flexible enough to accommodate a variety of user needs and use cases, rather than focusing on solving a single problem for a specific user. This approach can be challenging, especially when a company has important clients with very specific needs and wants to keep them happy.

However, it’s crucial to keep the long-term vision in mind. Catering too much to client-specific features can lead to technical debt and a fragmented product experience. By aiming to build a platform, we ensure that our features are versatile and scalable, providing a cohesive experience for all users and allowing the product to evolve more seamlessly over time.

It is often much easier to add client-specific features on top of a solid platform than to try to retrofit a platform around a collection of client-specific features.

Conclusion and Reflection

While user-centric feature design is a powerful approach, it’s essential to strike a balance between user needs and business goals. There will be times when user feedback conflicts with business requirements, technical constraints, or other factors. In such cases, it’s important to weigh the trade-offs and make informed decisions that align with the overall product strategy.

I believe that encouraging a user-centric feature design culture within your team can lead to more successful products, happier users, and a more collaborative and iterative development process.

I hope this framework and strategies help you design features that truly connect with your users and drive the success of your products. The key is to keep the user at the center of your design process and continuously seek feedback to ensure that you’re building the right features for the right people.