Loading course…
From Vague Tickets to Clear Plans
Created by Shaunak Ghosh
Learn a repeatable workflow to turn an unclear work ticket into a concrete implementation plan senior engineers can review before you code. You’ll practice clarifying requirements, defining an MVP, splitting work into small mergeable PRs, sequencing to de-risk unknowns, and attaching a testing and communication plan—using examples like “Add user search” and “Fix slow dashboard loading.”
Requirements
- Basic ability to read and edit code in an IDE
- Basic familiarity with GitHub as a place code lives (no advanced Git required)
- Comfort describing a bug/feature in plain language
What you'll learn
- Explain the intern-friendly workflow from ticket assignment to merged PRs and what ‘done’ looks like on a team.
- Turn a vague ticket into clarified requirements and acceptance-style success criteria by asking high-signal questions.
- Identify where to implement a change by building a quick mental model of the codebase and finding likely entry points.
- Create a dependency/unknowns map and use it to choose what must be done first.
- Define an MVP with explicit goals and non-goals that supports incremental merging.
- Break a feature or fix into vertical, PR-sized slices that can be merged safely over time.
- Sequence slices to deliver value early while de-risking uncertainty using timeboxed spikes where appropriate.
- Attach an appropriate testing approach to each slice and communicate how to verify changes.
- Recognize when to proceed independently vs escalate, and write high-signal help requests.
- Write a concise implementation plan that senior engineers can review before coding, including scope, approach, sequencing, and test plan.
Learning path
11 modules • Each builds on the previous one
1
Developer workflow from ticket to merge
Learn the standard team workflow (ticket → clarify → branch → commits → PR → review → merge → deploy) and what “done” means in practice. We’ll walk the lifecycle using example tickets like “Add user search feature” and “Fix slow dashboard loading.”
1 video6 min
2
Pull requests and reviewable changes
Understand what a pull request is, what reviewers look for, and why small PRs reduce risk. You’ll learn the minimum PR contents (summary, screenshots/logs, test plan) and how PRs relate to incremental delivery.
1 video5 min
3
Asking “what” to clarify tickets
Practice extracting what to build from vague tickets by asking targeted “what” questions: what problem, what user, what success metric, what constraints, what non-goals. Apply this to “Fix slow dashboard loading” by identifying which widgets, baseline/target times, and where performance is measured.
1 video6 min
4
Reading the code to find changes
Learn a repeatable approach to understand an unfamiliar codebase: run it, reproduce the issue, search for entry points, trace data flow, and identify “seams” to extend. Use examples like locating where “User list” is fetched before adding “user search.”
1 video4 min
5
Map dependencies and unknowns early
Learn to identify what your ticket depends on (APIs, schema changes, permissions, UI components, performance tooling) and where uncertainty lives. You’ll create a quick dependency map and label “unknowns” to de-risk first—especially for performance tickets like slow dashboards.
1 video8 min
6
MVP: build the smallest valuable thing
Learn MVP thinking for engineering: define the smallest end-to-end outcome that delivers value and can be safely merged. Apply it to “Add user search” by defining a minimal search experience and explicitly listing non-goals (filters, fuzzy matching, advanced ranking).
1 video4 min
7
Break work into vertical slices
Learn how to split work into thin, end-to-end “vertical slices” that can ship and be reviewed in small PRs. You’ll practice converting “Add user search” into slices like: behind-a-flag API support, minimal UI wiring, then relevance/UX improvements.
1 video6 min
8
Sequence slices to deliver value early
Learn how to order your slices so you deliver value early and reduce risk: de-risk unknowns first (spikes, instrumentation), then lay stable foundations, then user-visible value, then polish. Apply this to both example tickets: search feature and slow dashboard loading.
1 video5 min
9
Plan testing for each PR slice
Learn to decide what tests you need (unit, integration, end-to-end, performance checks) and when to write them as you merge incremental slices. You’ll produce a simple test plan for “user search” and a measurement plan for “slow dashboard loading.”
1 video7 min
10
Unblock yourself and ask for help
Learn when to keep going vs. escalate: set a timebox, define what “stuck” means, and ask for help with context (what you tried, what you found, specific question). Also learn how to communicate progress and blockers clearly in standups or async updates.
1 video5 min
11
Write a simple implementation plan
Combine everything into a short plan a senior can review before you code: problem statement, clarified requirements, MVP, approach, dependency/risk notes, PR slice list, sequencing, and testing plan. You’ll produce a complete plan for either “Add user search feature” or “Fix slow dashboard loading,” from assignment to mergeable PR outline.
1 video8 min
Start Learning
Begin your learning journey
Modules11
Duration59 min
Science-backed learning
In-video quizzes and scaffolded content to maximize retention.
Key concepts
Ticket-To-Merge Workflow (Branch, PR, Merge)What Makes A PR Reviewable (Single Goal, Clear Title, TL;DR)Clarifying Vague Requirements With Targeted Questions And ConstraintsBuilding A Mental Model Of An Unfamiliar Codebase (Docs, Run, Explore)Mapping Task Dependencies And Sequencing ConstraintsMVP Scoping (Goals Vs Non-Goals; Smallest Valuable Delivery)Vertical Slicing To Create Small, Mergeable PR IncrementsDe-Risking Unknowns Early Using Timeboxed SpikesChoosing Appropriate Test Levels (Unit, Integration, E2E, Manual) And Writing A Test ApproachGetting Unblocked: Asking For Help With Context, Artifacts, And HypothesesWriting Technical Planning Documentation For Senior Review (Requirements, Non-Functional Needs, Test Plan)