
Updated: May 2, 2025

As data scientists and engineers, we live at the intersection of complex data, sophisticated algorithms, and powerful infrastructure. We strive for accuracy, efficiency, and technical elegance. Yet, despite our best efforts, we've all experienced it: the perfectly tuned model that never gets fully adopted, the insightful dashboard gathering digital dust, the robust data pipeline feeding a feature users ignore.
Technical success doesn't automatically equate to impact. Shipping code or models isn't the goal; delivering value is. How can we ensure our considerable skills are directed towards solving the right problems and creating solutions—internal tools or external products—that truly make a difference?
The answer lies in evolving our workflow. We need to become comfortable and focused on the customer and embrace a process that continuously integrates learning, validation, and user feedback alongside our technical development. This isn't about abandoning technical rigor; it's about enhancing it with proven practices from product discovery and lean development. Specifically, it is about getting good at breaking down the ideal output of our models and how we can construct a powerful, high-impact DS&E workflow by combining traditional DS&E methods with insights from



Teresa Torres' Continuous Discovery Habits, David Bland's Testing Business Ideas, and Jeff Patton's Dual Track Agile.
We need to deliver value in small increments and learn how to share insights early and often while ensuring our model's accuracy through larger datasets. The trick is knowing how to test value with small datasets and keeping that value while you scale and train through larger datasets.
The High Cost of Building in Isolation
Before diving into the solution, let's acknowledge the cost of the status quo:
Wasted Effort: Hours spent building complex systems based on unverified assumptions about user needs or value.
Metrics Myopia: Optimizing for technical metrics (e.g., MAE, RMSE, y_hat) while missing critical signals about usability, trust, or business impact.
Solving Phantom Problems: Investing heavily in solutions for problems that aren't painful enough for users (internal or external) to change their behavior or adopt the new tool/feature. Also, over solving for problems when “good enough” works.
Missed Opportunities: Failing to uncover the most valuable problems to solve because we aren't continuously engaging with the people experiencing those problems.
Pillars of a Modern, High-Impact DS&E Workflow
Instead of building based on requirements handed down or assumptions made in isolation, we can adopt a more dynamic, evidence-driven approach built on three complementary pillars:
Pillar 1: Continuous Connection & Learning (Inspired by Teresa Torres)
What it is: Shifting from project-based research to ongoing engagement with users/stakeholders. This involves weekly or bi-weekly touchpoints (interviews, observations) to deeply understand their context, pain points, and desired outcomes. It emphasizes mapping the "opportunity space" (what problems could we solve?) before jumping to solutions, and generating assumptions directly from user interactions.
DS&E Relevance: Even for highly technical or internal projects, we need this direct line. Who will use this API? How does this model fit into the analyst's workflow? What does "better" actually mean to the platform team consuming our data service? Do we see early indications of customers responding positively to our model? Continuous discovery ensures we're grounded in real needs, not abstract technical goals. Opportunity Solution Trees become invaluable tools for mapping user needs to potential DS/E solutions and the underlying assumptions.
Example: An engineering team building a new MLOps platform component conducts short weekly feedback sessions with data scientists (their users) to understand deployment bottlenecks before finalizing features. At the same time the Data Scientist have evidence from experiments run with real customers that impact feature build backlog priority.
Pillar 2: Rigorous Assumption Testing (Inspired by David Bland)
What it is: Systematically identifying the assumptions underpinning any potential solution (technical, usability, value, viability). Crucially, it involves prioritizing the riskiest assumptions—those most likely to be wrong and most damaging if they are—and designing fast, cheap experiments to gather evidence before significant investment.

Extract your hypothesis, map your assumptions, and experiment to learn from customers. 
Value learning over output. Be confident in your learning records because they are based on customer validation. DS&E Relevance: This brings rigor to validating our hypotheses. For a predictive model: Is the data actually predictive of the outcome? (Feasibility). Will users trust the predictions enough to act on them? (Value/Usability). For a data pipeline: Can we reliably source the data? (Feasibility). Will the latency be acceptable for the downstream system? (Usability). Experiments might range from offline model evaluations to prototypes, A/B tests, or "Wizard of Oz" MVPs (simulating functionality manually).
Example: A data scientist assumes users will trust a new forecasting model. Before building the full UI integration, they run a "Concierge MVP": manually generating forecasts for a key stakeholder for two weeks, discussing the results, and assessing trust and usefulness.
Pillar 3: Parallel Tracks for Learning & Building (Inspired by Jeff Patton)
What it is: Structuring work into two concurrent streams: a Discovery track focused on rapidly learning, validating ideas, and reducing uncertainty (using techniques from Torres and Bland), and a Delivery track focused on building, testing, and releasing high-quality, scalable, production-ready code based on validated learnings from Discovery. Discovery continuously informs and de-risks what gets built in Delivery.
DS&E Relevance: This prevents the "build trap" where large, complex systems are developed without ongoing validation. The Discovery track is where DS&E teams can rapidly prototype algorithms, test data source viability, validate user interface concepts for dashboards, or run experiments on model impact. The Delivery track then builds the robust pipelines, scalable infrastructure, or polished user interfaces for the validated approaches emerging from Discovery.
Example: While the Discovery track tests different recommendation algorithms with a small user subset using rapid prototypes, the Delivery track builds the scalable serving infrastructure that any validated algorithm will eventually need.
The Integrated Workflow: Your DS&E Impact Engine
The real power emerges when these three pillars work together seamlessly:
Continuous Discovery (Torres) feeds the system: Ongoing user interactions constantly surface new opportunities, user needs, and assumptions. This provides the raw material for both tracks. Opportunity Solution Trees help visualize and prioritize.
Assumption Testing (Bland) provides rigor in Discovery: As assumptions arise (especially risky ones), Bland's experimental toolkit is used within the Discovery track to generate evidence quickly and cheaply. This validates or invalidates paths before they consume significant Delivery resources.
Dual Track Agile (Patton) provides the operational framework: It allows the team to manage the parallel streams. Learning from Discovery (fueled by Torres & Bland) directly de-risks and prioritizes the work queued for the Delivery track, ensuring that what gets built is valuable and validated. Feedback from delivered increments also loops back into Discovery.
Imagine a DS&E Team Scenario: Building an AI tool to help internal Sales reps prioritize leads.
Continuous Discovery (Torres): Weekly chats with Sales reps reveal their current prioritization methods are inconsistent and time-consuming (Opportunity Mapping). Key assumptions emerge: "Reps will trust AI scoring," "AI scores integrate easily with their CRM," "Scoring improves conversion rates."
Assumption Testing (Bland in Discovery): Riskiest = Trust. Experiment: Concierge MVP – a data scientist manually scores leads for 2-3 reps for a week, discussing the rationale and gathering feedback on trust and utility. Another experiment: Prototype showing how scores could appear in the CRM, testing usability assumptions.
Dual Track (Patton): Discovery: Running the Concierge MVP, iterating on scoring logic based on feedback, testing CRM integration mockups, potentially A/B testing scoring impact on a small scale if feasible. Delivery: Based on initial positive signals from Discovery, engineers start building the foundational data pipeline to pull necessary lead/customer data (a validated need regardless of the final scoring logic). Later, they build the CRM integration after the prototype validates the approach.
Outcome: The team learns quickly if reps trust the scores. If yes, Delivery builds the validated solution. If no, Discovery pivots (maybe simpler heuristics?) before wasting extensive Delivery effort on complex ML models reps won't use.
Getting Started: Weaving This into Your DS&E Work
Start Small: Introduce one habit – maybe 15-minute weekly user check-ins or identifying and testing just one risky assumption on your next project.

Charles Duhigg Ted Talk
Partner Up: Collaborate closely with Product Managers if you have them – they live and breathe these cycles. If not, find allies within your DS&E team to champion these practices.
Visualize: Use simple tools – an Opportunity Solution Tree on a whiteboard, a shared doc for assumptions, a basic Kanban board showing Discovery and Delivery lanes.
Embrace Learning: Frame experiments not as "pass/fail" for your idea, but as efficient ways to learn and make better decisions. Share learnings openly.
Conclusion: Build Less, Impact More
Marrying our deep technical expertise with a continuous cycle of discovery, rigorous validation, and dual-track development transforms how we work. By integrating the principles championed by Teresa Torres, David Bland, and Jeff Patton, Data Science and Engineering teams can move beyond just shipping features to consistently delivering high-impact solutions. It's a workflow designed for learning, adapting, and ultimately ensuring that our sophisticated skills create meaningful, measurable value for our users and our organizations. Let's start building smarter, not just harder.










































