If you’ve ever worked on a tech project where every team member had an answer but no one asked the right questions, you know how it feels to sprint in circles. It’s not fun, it’s not productive, and the application you’re building usually ends up resembling Frankenstein’s monster—but with more bugs.
The Question Formulation Technique (QFT), developed by the Right Question Institute, can save your app from this fate. But let’s be clear: it’s not just about group brainstorming or chaotic Q&A sessions where everyone’s opinion fills up the room and no real clarity emerges. Instead, QFT pairs beautifully with Domain-Driven Design (DDD), giving you a focused, purpose-driven method to interrogate your app’s goals and structure.
So, let’s break it down—without overemphasizing the group part of the equation. Because sometimes, the best ideas aren’t born in meetings; they’re born in moments of structured, thoughtful inquiry.
Why We Need Questions Before We Write Code
When building an application, there’s a tendency to leap straight to answers:
- “We need a shopping cart!”
- “Let’s use AI to fix that!”
- “Why not throw in a blockchain for good measure?”
This rush to solutions creates features no one asked for, architectures no one understands, and user experiences everyone complains about. Enter QFT, a method that forces us to slow down, frame the problem clearly, and ensure our design aligns with the real-world domain the app is meant to serve.
What is Domain-Driven Design (DDD)?
If QFT is about asking better questions, Domain-Driven Design (DDD) is about making sure those questions are rooted in the specific needs of your application’s domain. In simpler terms, DDD helps you align your code and architecture with the real-world processes and problems you’re trying to solve.
Key aspects of DDD include:
- Understanding the Domain: Getting intimate with the business processes or user needs that your app is designed to serve.
- Ubiquitous Language: Using consistent, domain-specific language across developers, stakeholders, and documentation to eliminate miscommunication.
- Bounded Contexts: Defining the scope of different parts of your app and avoiding the chaos of trying to make one-size-fits-all solutions.
Marrying QFT and DDD: A Match Made in Dev Heaven
QFT provides the questions, DDD ensures they’re grounded in reality. Here’s how the two work together:
Step 1: Focus on the Domain First
Instead of starting with technical solutions, anchor your questions in the domain. For example:
- “What is the core problem this app is solving for users?”
- “What are the key workflows or events in this domain?”
- “Who are the users, and what language do they use to describe their tasks?”
Questions like these help you avoid shiny distractions like overcomplicated features or irrelevant tech trends.
Step 2: Generate and Prioritize Questions
This is where QFT shines. Ask broadly at first, but then refine. Good examples include:
- “How do users currently solve this problem, and what frustrates them about those solutions?”
- “What happens if a user abandons their workflow halfway through?”
- “What does ‘success’ look like in this domain?”
Avoid the temptation to start proposing answers too soon. Remember: the point isn’t to solve the problem yet, but to ensure you fully understand it.
Step 3: Use Bounded Contexts to Narrow the Focus
Once you’ve prioritized your questions, use DDD to zoom in on smaller, manageable sections of the application. For example:
- In an e-commerce app, the “Cart” might be one bounded context, while the “Order Fulfillment” is another. Ask specific questions for each:
- “What happens when a product is removed from the cart?”
- “What rules govern when an order can be canceled?”
This prevents sprawling, disconnected discussions and keeps your questions targeted.
Step 4: Refine Your Model and Iterate
As you answer questions, use DDD principles to refine your app’s design and architecture. Did the questions reveal unclear processes or ambiguous workflows? Great! That’s where you dig in and clarify.
Why Groupthink Isn’t the Goal
Here’s the thing: too often, when teams “collaborate,” it turns into a noisy exercise in everyone trying to out-solution each other. This is the antithesis of what QFT and DDD aim to achieve.
Instead of groupthink, you want group questioning. This means:
- Giving space for individual voices to raise critical questions.
- Staying disciplined about prioritizing questions rather than jumping to answers.
- Using domain experts to validate and refine questions so they remain grounded.
It’s not about having more voices in the room; it’s about asking better questions in a deliberate, focused way.
The Results? Smarter Apps, Happier Users
By combining QFT and DDD, you get an application that’s not just built to “work” but built to work well for its intended purpose. Your features align with user needs, your architecture supports scalability and maintainability, and you spend less time playing “guess what the user wants.”
So, next time you’re tempted to dive into coding without questioning, stop. Ask yourself:
- What do we really need to know?
- Are we asking the right people?
- Are our questions rooted in the domain, or are we just winging it?
And most importantly, remember that the best code starts with great questions—not quick answers. Now, go build something brilliant (but only after you’ve interrogated it thoroughly).
Resources:
Books on Question Formulation Technique (QFT):
-
"Make Just One Change: Teach Students to Ask Their Own Questions" by Dan Rothstein and Luz Santana
This foundational book introduces QFT as a structured process to empower individuals to ask better questions, fostering creativity and engagement. It’s widely used in education but applicable to research and other problem-solving contexts. A must-read for learning the nuances of question-driven inquiry.
More about this book here. -
"The Question Formulation Technique for Research" by Andrew P. Minigan
A guide tailored for academic and professional researchers to use QFT for generating transformative research questions. While the focus is on research, its strategies can be applied to tech innovation and product design contexts. Learn more here -
"The Right Questions" (Articles and Guides from the Right Question Institute)
The Right Question Institute offers a plethora of resources and publications related to QFT’s applications in various fields, from teaching to business and beyond.
Explore their publications here.
Books on Domain-Driven Design (DDD):
-
"Domain-Driven Design: Tackling Complexity in the Heart of Software" by Eric Evans
This seminal work defines DDD and its principles. It’s essential for understanding how to align technical design with business needs and create software systems that truly solve the right problems. Find it here at amazon -
"Implementing Domain-Driven Design" by Vaughn Vernon
A practical follow-up to Eric Evans’ book, this resource offers actionable advice and examples for applying DDD in real-world software projects. Find it here at amazon -
"Domain-Driven Design Distilled" by Vaughn Vernon
A concise and accessible guide to the core concepts of DDD, perfect for those new to the methodology or seeking a quick refresher. Find it here at amazon -
"Patterns, Principles, and Practices of Domain-Driven Design" by Scott Millett and Nick Tune
This book combines DDD principles with patterns and best practices for implementing them, particularly in agile and enterprise environments. Find it here at amazon
Additional Resources and Suggestions:
-
Workshops and Online Courses
Many institutions and professionals (like the Right Question Institute for QFT and Vaughn Vernon for DDD) offer online workshops and training programs. Check their websites for schedules and materials. -
Communities and Blogs
Engage with communities on platforms like LinkedIn, Stack Overflow, or GitHub for ongoing discussions and case studies related to both QFT and DDD.
By integrating the questioning techniques of QFT with the domain-aligned focus of DDD, you can build applications that not only meet technical requirements but also address core user and business needs effectively.
