Catalog My learning Blog
Full-Stack Developer Course: React, .NET and SQL Server · Phase 1 · Lesson 1 · 7 min read

Frontend to Full-Stack Developer: What Changes

On this page
  1. Learning Objective
  2. Concept Explanation
  3. Worked Example: Why the Server Must Recompute the Price
  4. Real-World Examples
  5. Review Questions & Answers

Learning Objective

Describe precisely what a full-stack engineer takes responsibility for that a frontend engineer does not, explain why the browser is an untrusted environment from the server's point of view, and lay out how the 100-day core path, and the 50-day advanced track after it, build from a React and Angular background toward owning a complete system.

Concept Explanation

As a frontend developer you own the experience inside one browser tab. The code you write runs on a machine you do not control, in a runtime you cannot patch, and every user gets their own private copy of your application. If it breaks, it breaks for one person, and a refresh usually fixes it. As a full-stack engineer you take on the opposite situation: a single running copy of your code that every user shares, on a machine you do pay for and must keep healthy, holding data that people trust you never to lose or leak. The skills that transfer are large: component thinking, state management, HTTP, JSON, asynchronous programming, and a feel for what users notice. What changes is the cost of a mistake.

The most important mental shift is about trust. In a React or Angular application it is natural to treat the code as the authority: a button is disabled, so the action cannot happen; a form validates, so the data is valid; a route guard redirects, so the page is protected. From the server's point of view none of that is true. Anyone can open the network tab, copy a request as curl, edit any field, and replay it, and anyone can skip your interface entirely and call the API directly. Everything that arrives over the network is a claim made by an untrusted party until the server verifies it. Frontend checks exist for usability, and server checks exist for correctness and security. You need both, and they are not substitutes.

The second shift is about state and ownership. In the browser, state is disposable and belongs to one session. On the server, the database is the source of truth, many requests run at the same time against the same data, and two users can attempt to change the same record in the same millisecond. That introduces problems a frontend rarely meets: concurrency, transactions, idempotency, retries, partial failure, and schema changes that must work while the old version of the code is still running. Later phases of this course give each of these a dedicated lesson, and the path is ordered so that each new idea builds on the previous one.

The third shift is operational. A deployed server has to be observable, patched, backed up, scaled, and secured continuously. Logs, metrics, and health checks stop being optional. Secrets such as database passwords and signing keys become a class of data you must protect. And the blast radius of a vulnerability grows from one user's session to every user's data at once. That is why security is not a phase in this course but a thread through all ten: every lesson names the attack the design in front of you is meant to prevent.

This course uses React with TypeScript on the client, ASP.NET Core on .NET 10 for the API, SQL Server for storage, and Azure for hosting. Most of what you learn transfers directly to other stacks, because the underlying ideas, HTTP semantics, relational modeling, authentication protocols, and deployment pipelines, are the same everywhere.

ConcernFrontend viewFull-stack view
Who runs the codeThe user's device and browserA server you operate, shared by all users
Trust in inputMostly your own UI produces itAnything can arrive; every field is a claim to verify
StatePer session, disposableDurable, shared, concurrent
Failure impactOne user, fixed by refreshMany users, possibly data loss or exposure
DeploymentShip a bundle to a CDNShip code, migrate data, keep the old version serving
SecretsNone should exist in the bundleKeys and passwords you must store and rotate safely

Worked Example: Why the Server Must Recompute the Price

Consider a checkout call that a frontend developer might reasonably write on day one. The React code sends the price it displays, and a naive server trusts it. The first snippet shows the vulnerable shape; the second shows the correct shape, where the client sends only intent and the server derives every value that matters. You do not need to read the C# fluently yet; focus on which side decides the amount.

JavaScript
// React client: vulnerable design. The client states the price.
await fetch('/api/orders', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ productId: 42, quantity: 2, unitPrice: 19.99 }),
});
// Anyone can resend this with "unitPrice": 0.01 from the browser console.

// React client: correct design. The client states intent only.
await fetch('/api/orders', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ productId: 42, quantity: 2 }),
});
C#
// ASP.NET Core: the server looks up the price and validates the quantity.
app.MapPost("/api/orders", async (CreateOrderRequest req, ShopDb db, ClaimsPrincipal user) =>
{
    if (req.Quantity is < 1 or > 100)
        return Results.ValidationProblem(new Dictionary<string, string[]> { ["quantity"] = ["Must be between 1 and 100."] });

    var product = await db.Products.FindAsync(req.ProductId);
    if (product is null || !product.IsActive)
        return Results.NotFound();

    var order = new Order
    {
        UserId = user.GetUserId(),          // from the verified identity, never the body
        ProductId = product.Id,
        Quantity = req.Quantity,
        Total = product.Price * req.Quantity // computed here, from the database
    };
    db.Orders.Add(order);
    await db.SaveChangesAsync();
    return Results.Created($"/api/orders/{order.Id}", order.Id);
}).RequireAuthorization();

public record CreateOrderRequest(int ProductId, int Quantity);

Notice three decisions. The price comes from the database, not the request. The user identity comes from the authenticated principal, not from a userId field the caller could forge. And the quantity is range-checked even though the React form already limits it. Each of these will get its own lesson later.

A browser form and an attacker both call the order endpoint. Only the server, using the database and the verified session, decides the price and the user identity.
A browser form and an attacker both call the order endpoint. Only the server, using the database and the verified session, decides the price and the user identity.

Real-World Examples

  • In May 2019, security journalist Brian Krebs reported that First American Financial Corporation had exposed roughly 885 million document records through a website where changing a sequential number in the URL revealed another customer's files. The site treated the identifier as harmless and never checked that the requester was entitled to that specific document, a flaw class covered in the authorization lessons of Phase 5.
  • Stack Overflow has publicly documented in engineering blog posts that its main site is an ASP.NET application backed by SQL Server, serving very large traffic from a modest number of servers. It is a useful reminder that the stack in this course is not a toy or a legacy choice; it runs one of the most visited developer sites on the internet.
Key TakeawaysA frontend engineer owns an experience in a browser they do not control, while a full-stack engineer owns a shared, durable system. That system must treat every incoming byte as an unverified claim. Client-side checks improve usability, server-side checks provide correctness and security, and the server must never rely on the client for prices, identities, permissions, or any other decision that matters.

Review Questions & Answers

Disabling a button only changes what a cooperative user can do through your interface. Anyone can open the browser's developer tools, replay the request with different values, or call the API directly with curl or a script, and none of that passes through your form. The server therefore has to run its own validation on every request. The client validation still matters, but for a different reason: it gives fast feedback and reduces pointless round trips.

A userId in the body is just a value the caller typed, so any authenticated user could submit someone else's id and create orders on their behalf. The authenticated principal is produced by the server after verifying a credential such as a signed token or session cookie, so it cannot be changed by editing the request. Deriving identity from verified state rather than from request data is a rule you will apply in every endpoint you write.

A component runs in one user's browser, so the damage is limited to that session and a refresh normally clears it. A server bug executes against shared, durable data for every user, so a flawed calculation can corrupt many records, an authorization gap can expose everyone's information, and a mistaken migration can destroy data that cannot be recovered without a backup. The larger blast radius is why server code needs tests, reviews, logging, and rollback plans.

HTTP, JSON, asynchronous programming, TypeScript's type thinking, component and state design, and knowing what users perceive as slow or broken all transfer almost unchanged. What needs to be learned is a new language and runtime for the server, relational data modeling and transactions, authentication and authorization on the server side, concurrency, and operating a service in production. The first ten lessons close the language gap so the rest of the course can focus on those newer concerns.