Fullstack Development Ecosystem

TypeScript Essentials

TypeScript applied end to end: move from "blind" JavaScript to a type system that documents contracts, catches errors at compile time, and makes refactoring safe. The guide covers the full type system — basic types, functions, objects and interfaces, classes and OOP, generics, union types and type guards, utility types, advanced types (conditional, mapped, template literals), error handling and typed async, tooling configuration, and testing — across twelve modules that combine six independent mini-projects (one per module, to practice each concept in isolation) with an integrative evolving project: a Task Management API built progressively from module 7 through module 12, with a generic repository, the `Result<T, E>` pattern for error handling, authentication, and a Vitest test suite plus a CI/CD pipeline. By the end, the student has both conceptual mastery of the type system and a production-ready TypeScript API for their portfolio.

96 lecciones

React Fundamentals

Learn React's mental model: building interfaces as a function of state. The guide covers thinking in components and composition, JSX and rendering (including lists and why `key` matters), state with `useState` — and why it's a snapshot per render, not a value that updates instantly — events and handlers, derived versus stored state, effects for syncing with external systems, and how to lift shared state up to the common ancestor. The core idea is that the UI is a function of state: you describe what it looks like for a given state, and React handles updating the DOM when that state changes. Each module runs the pure logic behind React in Node.js — derived filtering and sorting, the cart reducer, a mini render-to-string, the render-commit-effect order — to verify the reasoning without depending on a browser. The throughline is Mercado's storefront: you break it down into components, add search with derived state, a cart with lifted state and a reducer, and an effect that loads the products. It's the core of NIEVA's Fullstack ecosystem, building on the HTML and CSS foundation.

64 lecciones

Nextjs App Router

Take a React app to production with the Next.js App Router: file-based routing, nested layouts, Server Components — the default: they render on the server and never ship their JavaScript to the client — versus Client Components, data fetching in `async` server components, dynamic routes with `params` and `searchParams`, loading and error UI with streaming, and Route Handlers alongside Server Actions to mutate data without writing a separate API. The core idea is the mental-model shift from a classic SPA: in the App Router the server is the default, and you deliberately decide which piece needs client interactivity — that changes where state lives, where data is fetched, and how much JavaScript reaches the browser. Each module runs the logic behind the framework in Node.js — route resolution, server/client classification, parallel versus waterfall fetching, revalidation after a mutation — to verify the reasoning. The throughline is Mercado's storefront ported to Next.js: its root layout, its home page with the catalog fetched on the server, its dynamic product route, and "add to cart" as a Server Action. It continues directly from the React Fundamentals Guide within NIEVA's Fullstack ecosystem.

64 lecciones

Frontend State And Data

Learn to manage a frontend app's state and data at scale: distinguish the four kinds of state — local, global client state, server state, and URL state — use Context without overusing it, choose a global store (Zustand pattern) when it's the right call, and, the guide's core focus, treat server state for what it is: a cache of remote data, handled with React Query (TanStack Query) for fetching, caching, revalidation, deduplication, and mutations. The core idea is that most "state management problems" are actually server state misclassified: it's not your state, it's a cached copy of the truth that lives on the backend. Each module runs a mini-version of the library in play in Node.js — a store with `getState`/`setState`, a query cache with stale-while-revalidate and deduplication, a mutation with invalidation and optimistic rollback — to verify the reasoning. The throughline is Mercado's storefront, already built in the React Fundamentals Guide: here its products come from the server via React Query, its cart is a global store, its search and filters live in the URL, and its theme is Context. It continues directly from the React Fundamentals Guide within NIEVA's Fullstack ecosystem.

64 lecciones

REST APIs & HTTP Fundamentals Guide

This guide teaches you the HTTP protocol and the REST principles behind every web API. Before you build APIs with FastAPI, you need to understand what a request is, what a response is, how status codes work, and how to design APIs that scale.

32 lecciones

Ui Systems And Design Implementation

Learn to implement design in code systematically: move from writing loose CSS for each screen to a real design system, with design tokens (color, spacing, and typography as meaningful variables), utility-first CSS with Tailwind, spacing and typography scales, accessible color and contrast measured with WCAG, components with variants (a `Button` or `ProductCard` configured through props, the `cva` pattern), dark mode and responsiveness inside the system, and accessible primitives in the shadcn/Radix style. The core idea is consistency at scale: when every color, space, and component comes from a system instead of an ad-hoc decision, the interface looks coherent, maintains itself, and is accessible by default. Each module runs the system's logic in Node.js — token resolution, mapping Tailwind utilities to CSS, WCAG contrast calculation, variant resolution — to verify the system is coherent and accessible, not just that it "looks good." The throughline is Mercado's storefront design system: its light and dark tokens, its Tailwind configuration, its `Button` and `ProductCard` with variants, and its responsive, accessible UI. It builds on the Web Fundamentals Guide and the React Fundamentals Guide within NIEVA's Fullstack ecosystem.

64 lecciones

Authentication & Authorization Guide

This guide teaches you how to implement complete authentication and authorization: password hashing, JWT tokens, OAuth2 flows, RBAC with roles and permissions, security headers, and FastAPI's native Security integration.

48 lecciones

Fullstack Performance And Deployment

Learn to make a frontend app fast and ship it to production: what "fast" means in measurable terms through the Core Web Vitals (LCP, INP, CLS), rendering strategies (CSR, SSR, SSG, ISR) and where each piece of code runs, the critical rendering path and what blocks the first paint, the real cost of JavaScript (bundle size, code-splitting, lazy loading, re-renders), images and assets with modern formats and HTTP caching, how to measure and profile with Lighthouse and the Performance panel, and deployment itself: production builds, hosting, environment variables, CDN/edge, CI/CD, and rollbacks. The core idea is measure before you optimize: performance isn't magic or micro-tricks, it's a budget you measure, diagnose, and defend. Each module runs a model of the metric or mechanism in play in Node.js — Web Vitals scoring, bundle size with code-splitting, time to first render, HTTP caching decisions, image byte savings, a performance budget — to verify the reasoning with numbers, not intuition. The throughline is Mercado's storefront: its baseline gets measured, it gets optimized (code-splitting the cart, AVIF images with `srcset`, asset caching, critical path), it meets a budget, and it gets deployed. It closes out NIEVA's Fullstack ecosystem, building on the UI Systems and Design Implementation Guide.

64 lecciones

PostgreSQL & SQLAlchemy Guide

Learn PostgreSQL from installation to optimized queries, model your data with the SQLAlchemy ORM, manage your schema with Alembic, and integrate everything asynchronously with FastAPI. This guide replaces in-memory data with real, professional persistence, exactly as it is used in production. Built for developers who have already built APIs with FastAPI and need to take the next step: a well-designed relational database that scales.

48 lecciones

Security for AI-Generated Code

45% of AI-generated code contains security flaws (Veracode 2025). Java: 72% failure rate. JavaScript: 43%. Python: 38%. XSS: 86% of AI code fails. Larger models don't generate more secure code. This guide teaches you to detect, prevent, and fix vulnerabilities in code produced by any AI tool — OWASP Top 10 applied to AI code, vulnerability patterns by language, detection tools, security review checklists, hardening techniques, and secrets management.

32 lecciones

Testing Backend Applications Guide

Learn backend testing end to end: pytest fundamentals, fixtures, mocking with unittest.mock and pytest-mock, integration testing with test databases and factories, E2E testing with the FastAPI TestClient, coverage with pytest-cov, the TDD workflow, and CI with GitHub Actions. Build a production-grade test suite with 80%+ coverage.

48 lecciones

System Design Fundamentals

Learn to design a distributed system from scratch and scale it with judgment, not memorized answers. This guide teaches the complete method — clarifying requirements, estimating capacity with back-of-the-envelope math, modeling data, adding caching, scaling the database, balancing load, and reasoning through reliability and consistency tradeoffs — using a single real case study from start to finish: Enlace, a URL shortener that starts as a single box and scales module by module into a full distributed design. Every number that appears is calculated and executed in Python (QPS, storage, hit ratio, consistent hashing), never quoted from memory. By the end, you can take a vague prompt like "design a URL shortener" and produce a defensible design with numbers, a diagram, and explicit tradeoffs — exactly what's expected in an architecture review or a system design technical interview.

64 lecciones

Monitoring & Observability Guide

Master the observability of AI systems in production with OpenTelemetry, the industry standard for 2026. Learn to instrument LLM applications with traces for prompts, embeddings, and tool calls, build dashboards for latency and cost, design alerting strategies, implement AI-specific monitoring (prompt quality, token usage, model drift), and debug production issues like hallucinations and cost spikes. Integrates with LangSmith and monitoring backends.

64 lecciones

Building with LLMs in Code

Integrate an LLM into a real product from code, not from an experimentation notebook. This guide works directly against the provider's SDK — on purpose, so you understand what a framework abstracts away before you adopt one — across eight modules: treating the LLM as just another dependency of your software (non-deterministic, billed by token), building your first serious integration with your own client, keeping prompts as versioned code, getting structured, validated outputs instead of parsing free text, giving the model tools through tool calling controlled by your code, streaming responses, hardening the integration against real provider failures, and evaluating and shipping with an eval suite that tells you whether a change made the system better or worse. The final project is a production-ready support-ticket triage service: Pydantic-validated classification, streaming responses, real tools, retries, caching, cost control, and evals running in CI.

64 lecciones

Debugging and Troubleshooting

Take an unknown failure — a thirty-line traceback, a silently wrong result, a regression buried under two hundred commits, or a test that fails once every thirty runs — and learn to reproduce it, corner it down to the exact line, and explain it with evidence, before asking a model anything; and when you do ask, learn to verify whether the answer is correct. The six modules move from reading the failure (what a traceback is already telling you) to the method that goes from symptom to root cause, to the debugger for stopping the program and looking inside, to logging for diagnosing what already happened, to bisection for cornering regressions and intermittent failures, and close with AI in the loop: using it after you understand the error, not instead of understanding it. The final project is a debugging dossier on a repository with five failures of different natures — including a regression that requires `git bisect run` — resolved with protocol, evidence, and a regression test.

48 lecciones

Working with Coding Agents

Learn to direct coding agents as a professional craft, not improvisation. This guide covers the six pieces that separate amateur use from professional use: the craft of directing instead of writing code directly, spec-driven development, harness engineering — the environment, context, and permissions you set up so the agent can verify itself — verifying and reviewing what the agent generates, budgeting and controlling token and time cost, and governing AI-generated code within a team. By the end, you can write executable specifications, prepare an agent-ready repository, review — not just accept — what an agent produces, control how much you spend in tokens and human attention, and write the playbook that governs how your team works with agents.

48 lecciones

Deployment & System Design Guide

Take your Python API from localhost to production on real cloud platforms (Render, Railway, Fly.io), set up managed databases (Supabase, Neon), Redis in the cloud (Upstash), a reverse proxy with Nginx, and master the fundamentals of System Design: monolith vs microservices, caching layers, message queues, scaling strategies, and API versioning. Guide #15 and the LAST one in the Backend Python Developer with FastAPI Path — the capstone that closes out the whole path.

74 lecciones