What you must be able to prove
Software development is the disciplined process of turning a real problem into a working, testable and maintainable software system. This module gives you the mental model you will use throughout the Master Class before you begin writing serious code.
Explain the difference between a problem, a feature and an implementation.
Describe the basic relationship between frontend, backend, database and deployment.
Trace a simple web request from a user's browser to a server and back.
Use a professional build loop: understand, plan, build, test, debug, document and ship.
Identify evidence that proves a software feature actually works.
1. Software development begins with a problem
Professional developers do not begin with code. They begin by defining who has a problem, what successful behaviour looks like and what constraints matter. A feature is a proposed solution to that problem. Code is only one implementation mechanism. Keeping these three levels separate prevents you from building technically impressive software that solves the wrong problem.
2. The four-part web application mental model
Most modern web applications can be understood through four cooperating layers. The frontend is what the user sees and interacts with. The backend receives requests, applies rules and coordinates work. The database stores durable information. Deployment makes the system available outside your computer. Real products often add authentication, queues, storage, analytics and AI, but these four layers remain a useful starting map.
3. Follow the request, not the framework
When a user clicks a button, the browser may update locally or send a request to a server. The server validates the input, checks authorization, reads or writes data and returns a response. The frontend then turns that response into visible behaviour. If you can trace data through this path, you can debug systems built with many different frameworks because the underlying request-response model remains understandable.
4. The professional build loop
Use the same loop on every project: understand the requirement, define the smallest expected behaviour, build one vertical slice, test the happy path, test a failure path, debug with evidence, document the decision and ship a reproducible result. Avoid changing several layers at once when you do not understand the failure. Reduce uncertainty before increasing complexity.
5. Debugging is evidence collection
A bug is a difference between expected behaviour and observed behaviour. Before changing code, reproduce the problem, inspect the inputs, inspect the output, isolate the smallest failing step and state what should have happened. Random edits may occasionally work, but they do not build engineering judgment. Evidence-driven debugging does.
6. Proof is part of the product
A developer should be able to prove that work functions. Useful proof can include a deployed URL, automated test, screenshot, API response, repository commit, reproducible README or a short demonstration. Throughout this Master Class, completed learning should become visible evidence that another person can inspect rather than private notes that disappear after a lesson.
Turn the lesson into a concept map.
Build your first developer mission map
- Choose one everyday problem that could reasonably be improved with a web application.
- Write one sentence describing the user and the problem without mentioning technology.
- Define one user action that would prove the smallest useful version works.
- Sketch the four layers: frontend, backend, database and deployment. Write what each layer would be responsible for.
- List one happy-path test and one failure-path test.
- Create a README.md containing the problem, expected behaviour, system map and tests.
A GitHub repository containing a clear README.md mission map. No complex code is required yet; the evidence is your ability to define the system before building it.
4 questions · 70% required to pass.
Answers are graded on the server and recorded in your learner gradebook. Complete the lesson first, then take the assessment without answer hints.
Take graded assessment →Before continuing, explain your chosen app idea in four sentences: the user problem, the smallest useful action, the four-layer system map and the evidence that would prove success.
Turn this module into a demonstrable feature inside your capstone.
Submit working behaviour, a useful README, live proof when appropriate and a short explanation of the hardest engineering decision.
Think in code, then ask for review.
The Code Review agent is grounded in this module and can remember your prior signed-in learning interactions.