Why Asking Questions Matters for Software Developers

I believe that one of the foundational skills that makes a great software developer is the ability to ask thoughtful questions.

Before we can build the right thing, we need to understand the problem we’re solving, the assumptions we’re making, and the outcomes we want.

Those questions can be technical, business-focused, product-focused, or all of the above. Let’s look at a few scenarios to get a sense of the questions I might ask myself or others.

Scenario 1: Designing an API to serve data

You’re a backend dev on a team building a new application, and you need a way to surface some mystical nascent data from an existing database.

Some high-level questions that immediately pop into my mind:

What database tables are we pulling from?
What values do we need from the tables we’ve identified?
Do we need to perform any data manipulation once we get it back from the DB, but before we surface it via the API?
Is this a net-new repo that will require configuration to make DB calls?
- If it is new:
  - What language do we want to use?
  - Is there an existing package we can use to connect to the DB?
  - What sort of configuration options do we need for calling the DB (timeouts, multi-env setup, etc.)
  - How will deployments work?
  - What happens if the DB goes down?
- If it’s pre-existing and a DB connection is already set up:
  - How do we set up new calls to the tables we want?
    - Are there existing project conventions we need to follow?
Are we surfacing this data via REST calls? GraphQL?
What does authentication look like?

I could go on for longer, but you get the idea.

Ask questions early and deliberately. A thoughtful question can expose an assumption before it becomes an expensive implementation mistake.

Scenario 2: You’re discussing some designs with your team’s UX designer

Let’s say your team is in the early stages of a project and your UX designer wants to run some ideas by you. For simplicity’s sake, we’ll pretend the designs are for a new feature in an existing entertainment tracking web app. It already allows users to track the video games they’ve played, but now we’re going to add tracking for movies they’ve watched.

Here’s the example mockup we’ll work with:

For this example, we can pretend the UX designer is sneaking in some new UI elements that aren’t currently implemented:

Goal tracker
Next up feature

Focusing on those two things, these are some of the questions I might ask them and think to myself:

Goal tracker
- Do they have designs for the UI to allow users to set their goal?
- How are we going to store goals?
- Do we need to support historical lookup for past years?
- Are we scoping to just yearly goals for MVP or are we allowing monthly goals as well?
- What error state do they want to render if goal fetching fails?
- Is the circle tracker a net-new component or can we leverage an open-source package?
Next up feature
- Are these dynamic suggestions based on users’ viewing habits?
  - If so, does our current data shape support an algorithm to make this possible?
  - If not, where do the suggestions come from?
- What is supposed to happen when someone clicks “Add to watchlist”?
  - If an API call happens on click, and the request fails, what should we render?
- Does the movie watchlist design match the video game wishlist design (pretending the video game portion already exists)?

You can see how important it is to ask thoughtful questions at this stage in development. Depending on the answers to those questions, they can influence how you design components, APIs, error states, etc.

These conversations also give your UX designer insight into the problems you’re thinking about and help build a more collaborative relationship.

Scenario 3: You’re discussing a new AI feature with your product manager (PM)

Your product manager is starting some research on a new AI feature and wants some input. The specifics aren’t terribly important right now as you’re discussing big picture ideas.

Some of the questions I might ask to kick off the conversation would be:

What problem are we trying to solve?
Do people actually want this?
- If we’re not sure, what research can we perform to get a pulse check?
Do we have any infrastructure already in place to build AI-powered applications?
With the features they want, how much might this cost?
- At this stage, it’s probably too early to tell, but it’s worth thinking about.
What is the minimum set of features they’d be willing to go live with?
What legal, compliance, or safety risks are associated with building the AI application?
- Who do we talk to to get those answers?
Does this new feature fit into an existing monetization strategy for the company?
- If not, how do we offset and/or justify the cost of using generative AI?

Asking any of those questions will likely spark a good discussion with your PM. Even if you don’t get answers right away, the questions expose assumptions and risks that you can continue exploring during technical research and planning.

Conclusion

Thoughtful questions are valuable at every stage of development. They uncover hidden requirements, expose assumptions, and save you from headaches down the road.

If you’re stuck and not sure what to ask, think about the following:

“What assumptions are we making?”
“Is there a better a way to do this?”
“What problem are we solving?”
“What happens when things break?”

Those questions won’t answer everything, but they can open the door to better conversations, better decisions, and better software. I hope these scenarios help you go a little deeper on your next project.

Stay curious!