Engineering Problem Solving
A compact method for getting unstuck: frame the outcome, reduce uncertainty, choose one useful step, test it, and learn from what happens.
You do not need a complete specification before writing code. You need enough clarity to name the next question, enough scope to avoid solving the wrong problem, and a step small enough to produce evidence quickly.
Choose the problem you have
Four tools cover the moments where a project most often stalls.
Answer nine questions about the outcome, actors, data, boundaries, unknowns, and first slice. Get a roadmap made from your answers.
Break it into user capabilities and testable leaves. See where a decomposition is vague, layer-only, or too broad.
Respect dependencies, compare value and effort, and pull risky learning forward without pretending a score is objective.
Start from one symptom, gather evidence across the system, and choose the probe that best separates the remaining causes.
The curriculum
Eight modules, three lessons each. Read only the module that matches where you are stuck.
Turn a request into an outcome, the people involved, and a concrete definition of done.
Name constraints, assumptions, invariants, and what is deliberately outside the first version.
Replace vague topics with answerable questions and the smallest experiment that could answer each one.
Split the problem by user capability into pieces that can be built and observed independently.
Respect dependencies, expose risk early, and select the smallest useful vertical slice.
Use examples, predictions, and small prototypes to meet reality before the whole system is built.
Reproduce the symptom, form a hypothesis, and gather evidence that separates possible causes.
Write down what changed, update the model, and keep ownership of decisions when using tools or AI.
Then hand off
Problem solving finds the right engineering question. The specialist domains teach the mechanism and implementation.
Choosing and implementing algorithms
Responsibilities, interfaces, state, and tests
Models, queries, transactions, and storage
Requests, dependencies, failure, and production
Contracts, errors, idempotency, and evolution
Architecture, scale, and reliability