Published / updated29 Aug 2026

Industry and Developer Tools

Before you start

You need: nothing. This is stage one of the guided path.

Time: 8–10 classes' worth of reading in Track 02, plus a few hours installing and verifying your tools.

New to all of this? Start here explains what an application is made of and introduces the school system every example uses. Any word you do not recognise is in the glossary.

Learning objective

Understand how a software team works and get a machine ready to build the School Management System end to end.

Topics

• What a software team does, and where a fresher fits
• Requirements, sprints, environments and releases
• The tools you will use every day
• Preparing your machine
• The feature this track follows

What this stage covers

This is the guided path. It does not teach the material — it sequences it, shows how each stage connects to the next, and follows one feature all the way through.

Stage 1 covers two things that are easy to skip and expensive to skip: how a software team actually works, and getting your tools working before you need them.

Freshers who skip the first arrive on a team not knowing what a sprint is, what acceptance criteria are, or who to ask. Freshers who skip the second lose their first three days to an SDK that is not on PATH and a SQL Server they cannot connect to.

You will learn	Why it matters here
Team roles	You will know who to ask when stuck
Requirements and acceptance criteria	Every later stage starts from one
Application layers	The whole path is layered — browser, API, service, repository, database
Environments	Explains why "it works on my machine" is not an answer
Visual Studio, VS Code, SSMS, Postman, Git	The five tools you will open daily

Worked flow: the fee receipt

This track follows one feature across all ten stages: printing a fee receipt for Ravi Kumar, NCA-2024-0012.

At this stage the feature exists only as a request:

From:    Accounts clerk, NexCoding Academy
Subject: Fee receipts

Parents ask for a receipt when they pay. I write them by hand.
Sometimes the amount does not match what the system shows,
and I have to check the register.

By stage 10, that request will be a working screen backed by an API, a repository and a SQL Server table, with tests, a deployment and an explanation you can give in an interview.

Right now the only correct action is to ask questions, not to write code:

• What must appear on the receipt — amount, date, mode, balance, school details?
• Who may print one?
• Can a receipt be reprinted, and does the reprint say so?
• What happens for a partial payment?
• Should it be a PDF, or a print-styled page?

A developer who starts coding before answering these builds the wrong receipt. Track 02 turns these into acceptance criteria.

Where to learn it

Topic	Read
Team roles and how work reaches you	Track 02 — Software teams and roles
Requirements, user stories, acceptance criteria	Track 02 — Requirements
Application layers and request flow	Track 02 — Application layers
Sprints, environments, the lifecycle	Track 02 — Environments and SDLC
Testing and defect reports	Track 02 — Testing and quality
Release, deployment, incidents	Track 02 — Release and support
Visual Studio and VS Code	Track 15 — Visual Studio, VS Code
SQL Server and SSMS	Track 15 — SQL Server and SSMS
Postman and Swagger	Track 15 — Postman and Swagger
Browser DevTools and npm	Track 15 — Browser and frontend tooling
The full workstation setup	Track 15 — Workstation setup lab

Do Track 02 in full — it is short. Take Track 15 alongside the later stages rather than all at once; the Postman and DevTools material makes more sense once you have an API to call.

Stage exercises

From the guided path syllabus, adapted to the fee receipt:

Translate a requirement into tasks and acceptance criteria. Take the accounts clerk's message above and produce one user story with at least six acceptance criteria, including one for who is allowed to print and one for a partial payment.

Trace UI → API → database flow. On paper, draw what happens when the clerk clicks "Print receipt": which layer receives it, which decides whether they may, which reads the data, which formats it. You will build all five over the next nine stages.

Debugging drills

Follow a failed API request from browser to SQL. You cannot do this yet — you have no API. But set the habit now: open any website, press F12, open the Network tab, reload, and find one request. Read its method, path, status code and response body. That single skill decides whether a failure is frontend or backend, and Track 17 builds it into a method.

Practice

1. Read Track 02 end to end. It is seven short articles.
2. Install the .NET 9 SDK, Visual Studio 2022, VS Code, SQL Server Developer with SSMS, Node 20, Git and Postman.
3. Verify each one: Visual Studio opens and its New Project dialog offers .NET 9.0; node --version and git --version in a terminal; and a successful SSMS connection.
4. Run dotnet dev-certs https --trust. Without it, every HTTPS launch later fails confusingly.
5. Configure Git: your name, your email, init.defaultBranch main, and core.autocrlf for your OS.
6. Create a GitHub repository for your work on this track and clone it.
7. Write the six clarification questions you would ask the accounts clerk.
8. Draw the five layers and write what each will do for the fee receipt.
9. Open DevTools on any site and read one request's status code and response body.
10. Write down which role you would ask each of your six questions.

Do not skip 2 to 5. Every later stage assumes a working machine, and diagnosing a broken setup mid-project is the worst time to do it.

You can now

• Describe how a software team works and where a fresher fits
• Say what a sprint, a user story and acceptance criteria are
• Name the five application layers
• Install and verify Visual Studio, SQL Server, SSMS, Git and Postman
• Ask the clarifying questions a feature request needs

Review questions

1. What is a sprint, and what are acceptance criteria?
2. Which five layers will the fee receipt pass through?
3. Why must you ask the accounts clerk questions before writing any code?
4. What does dotnet dev-certs https --trust prevent?

Next: C# foundation