Job-Ready Multi-Stack Full-Stack Developer

Curriculum

What's inside

63 modules · 450 lessons

1. 01

   Stage 0 · How the Web Actually Works

   7 lessons
   • The Four Boxes: Browser, Client, Server, Database
   • DNS: Turning a Name Into an Address
   • HTTP and HTTPS: Methods, Status Codes and Headers
   • Checkpoint: Reading a Request Like a Developerquiz
   • Drill: The Vocabulary You Will Use Every Dayfill blank
   • + 2 more lessons
2. 02

   Stage 0 · Editor, Terminal and Browser

   7 lessons
   • Install VS Code and Configure It Like a Professional
   • Extensions That Earn Their Keep: Trust, Privacy and Performance
   • A Terminal You Can Trust: PowerShell 7, Windows Terminal, bash and zsh
   • Environment Variables, PATH, Processes, Ports and Permissions
   • Shell and Tooling Drill: Fill in the Missing Piecefill blank
   • + 2 more lessons
3. 03

   Stage 0 · Git and GitHub, Used Properly

   7 lessons
   • Your First Repository: init, add, commit, log
   • Seeing What Changed: status, diff, log and Safe Undo with restore
   • Drill: Choose the Exact Git Commandfill blank
   • Branches, Merging, and Resolving Your First Conflict
   • Remotes and GitHub: clone, push, fetch, pull and .gitignore
   • + 2 more lessons
4. 04

   Stage 0 · The Toolchain: Install Only What You Need Yet

   7 lessons
   • Install Late, Install Once: The Toolchain Policy
   • The Stage-0 Five: Install and Verify on Windows, macOS and Linux
   • Hardware Reality: The 8 GB Wall
   • Checkpoint: Policy, Categories and Platform Commandsquiz
   • Version Policy: Latest Stable or Active LTS, Never a Hard-Coded Patch
   • + 2 more lessons
5. 05

   Stage 0 · AI Assistants as Engineering Tools

   7 lessons
   • Write the Plan Before You Write the Prompt
   • Hallucinated APIs: Verifying That a Method Actually Exists
   • Checkpoint: Judging AI Output Like an Engineerquiz
   • Testing a Generated Implementation Against Your Own Cases
   • Naming the Security Risk in Generated Codefill blank
   • + 2 more lessons
6. 06

   Stage 1 · Semantic HTML and Accessible Forms

   7 lessons
   • Div soup and what it actually costs you
   • Headings are the outline, alt text is the rest of it
   • Checkpoint: structure, landmarks and text alternativesquiz
   • Forms that name themselves
   • Drill: the attributes that carry the meaningfill blank
   • + 2 more lessons
7. 07

   Stage 1 · Modern CSS: Box Model, Flexbox, Grid

   7 lessons
   • The Box Model and box-sizing: what `width` actually means
   • Cascade, Specificity, Inheritance — and Custom Properties
   • Checkpoint: Boxes, the Cascade, and Sizing Trapsquiz
   • Flexbox: Laying Out One Dimension
   • CSS Grid: Two Dimensions, and How to Choose Between Them
   • + 2 more lessons
8. 08

   Stage 1 · JavaScript Fundamentals

   7 lessons
   • Values, types, and the equality traps
   • Functions, scope, and closures
   • Checkpoint: values, scope, and closuresquiz
   • Objects and arrays: references, copies, and safe reads
   • Array methods that replace your loops
   • + 2 more lessons
9. 09

   Stage 1 · The DOM, Events and Browser Storage

   7 lessons
   • ES Modules in the Browser: import, export and the end of script order
   • Selecting, Creating and Rendering Elements
   • Checkpoint: Modules, Selection and Renderingquiz
   • Events, the Event Object and preventDefault
   • Event Delegation: One Listener for a Whole List
   • + 2 more lessons
10. 10

    Stage 1 · Async JavaScript and the Fetch API

    7 lessons
    • How JavaScript Runs: The Event Loop in Plain Terms
    • Callbacks, Promises, and async/await
    • fetch Without Illusions: response.ok, Status Codes, JSON, and AbortController
    • CORS from the Browser's Side
    • Drill: Async and fetch Syntaxfill blank
    • + 2 more lessons
11. 11

    Stage 1 · Algorithms and Data Structures, the Working Subset

    7 lessons
    • Arrays, Objects, Maps and Sets: Choosing the Container That Wins
    • Big-O as a Decision Tool, Not Exam Trivia
    • Searching and Sorting at the Level Interviews Ask
    • Recursion Basics: Trees, Base Cases and the Call Stack
    • Write the Test, Then Optimise
    • + 2 more lessons
12. 12

    Stage 2 · TypeScript: Types That Earn Their Keep

    7 lessons
    • Strict Mode From Day One
    • Primitives, Arrays and Objects
    • Aliases, Interfaces, Unions and Intersections
    • Drill: Write the Annotationfill blank
    • Functions That Declare Their Contract
    • + 2 more lessons
13. 13

    Stage 2 · Generics, Modules and Design

    7 lessons
    • Generics: one function, many types
    • Checkpoint: generics, constraints and utility typesquiz
    • Utility types: reshaping the types you already have
    • Fill in the typefill blank
    • Modules, barrel files and import discipline
    • + 2 more lessons
14. 14

    Stage 2 · npm, Linting and Formatting

    9 lessons
    • Installing Node.js the Maintainable Way
    • Check: Node.js Version Managersquiz
    • package.json: The Contract Your Project Makes With Every Machine
    • Semver Ranges and the Lockfile: Intent Versus Record
    • npm Scripts: The Project's Command Menu
    • + 4 more lessons
15. 15

    Stage 2 · Unit Testing and Refactoring

    7 lessons
    • Tests as a design tool: Arrange, Act, Assert
    • Testing behaviour, not implementation
    • Drill: the vocabulary of a trustworthy suitefill blank
    • Fixtures and factories: test data you can trust
    • Mocks, fakes, and the two instruments people turn into targets
    • + 2 more lessons
16. 16

    Stage 3 · Relational Modelling and Constraints

    9 lessons
    • Installing PostgreSQL, psql and a GUI Client
    • Quiz: PostgreSQL Installationquiz
    • Tables, Rows and Columns: the Type Is Your First Constraint
    • NOT NULL, UNIQUE and CHECK: Rules the Database Enforces for You
    • Checkpoint: Types, NULLs and Column Rulesquiz
    • + 4 more lessons
17. 17

    Stage 3 · Querying: SELECT, JOIN, Aggregate

    7 lessons
    • Reading Data: SELECT, WHERE, ORDER BY, LIMIT
    • Joins: What Each Join Really Returns
    • Syntax Drill: SELECT and JOINfill blank
    • From Rows to Answers: Aggregates, GROUP BY, HAVING
    • NULL and Three-Valued Logic
    • + 2 more lessons
18. 18

    Stage 3 · Transactions, Indexes and Query Plans

    7 lessons
    • All or nothing: transactions, COMMIT and ROLLBACK
    • Isolation levels: what two connections see at the same time
    • Checkpoint: transactions and isolationquiz
    • Indexes: what they buy and what they cost
    • EXPLAIN and EXPLAIN ANALYZE: reading the query plan
    • + 2 more lessons
19. 19

    Stage 3 · Migrations, Integrity and Operations

    7 lessons
    • Migrations: Schema Change as Versioned Code
    • Seed Data You Can Run Twice
    • Backups and the Restore Drill
    • Roles, Least Privilege and Keeping Secrets Out of the Repo
    • psql Day-to-Day: Inspect, Move Data, Unstick
    • + 2 more lessons
20. 20

    Stage 3 · Project: The Project-Management Database

    7 lessons
    • Design the schema: from feature list to ER diagram
    • Migrations and seed data: rebuild the world from zero
    • Query lab: who owns what, and what's still open?sql lab
    • The twenty-query workout
    • Indexing: make it fast, and prove it with EXPLAIN
    • + 2 more lessons
21. 21

    Stage 4 · React Foundations: Components, Props, State

    7 lessons
    • Why a UI Library at All
    • Scaffolding React with Vite and TypeScript
    • Components Are Functions, Props Are Their Parameters
    • Checkpoint: Setup, TSX and Propsquiz
    • useState and the Snapshot Model
    • + 2 more lessons
22. 22

    Stage 4 · Events, Forms and Controlled Inputs

    7 lessons
    • Handling Events in React with TypeScript
    • Controlled and Uncontrolled Inputs: Who Owns the Value
    • Checkpoint: Events, Types and Who Owns the Valuequiz
    • Form State, Validation and Submitting Without Lying to the User
    • Accessible Forms: Labels, Error Wiring and Focus After Submit
    • + 2 more lessons
23. 23

    Stage 4 · Effects, and When You Do Not Need One

    7 lessons
    • What useEffect Is For: Synchronising With Systems Outside React
    • Dependency Arrays, Cleanup, and the Infinite Loop
    • Drill: Effect, or No Effect?fill blank
    • You Do Not Need an Effect: Derived State, Handlers, and key
    • Strict Mode's Double Invocation, and Why It Is a Feature
    • + 2 more lessons
24. 24

    Stage 4 · Routing and Server State

    7 lessons
    • The URL Is State: Routes, Links and the 404 You Must Not Forget
    • Params, Nested Routes and Layouts
    • Checkpoint: Routing Decisions and the Shape of a Responsequiz
    • Four Real States: Loading, Empty, Error and Success
    • Race Conditions and AbortController
    • + 2 more lessons
25. 25

    Stage 4 · Composition, Performance and Error Boundaries

    7 lessons
    • Composition Over Prop Drilling: children and Slots
    • Context, Used Sparingly
    • Custom Hooks: Reusing Behaviour, Not Markup
    • Checkpoint: Composition, Context and Hooksquiz
    • What Actually Re-Renders, and What memo Really Costs
    • + 2 more lessons
26. 26

    Stage 4 · Testing React and Building the Client

    7 lessons
    • Test what the user does, not what the component is
    • Checkpoint: queries, user-event and the testing boundaryquiz
    • Testing forms: labels, typing, validation and payload shape
    • Async UI, error states and mocking at the network boundary
    • Recall drill: the testing API you will type every dayfill blank
    • + 2 more lessons
27. 27

    Stage 5 · Node, HTTP and REST API Design

    9 lessons
    • An API Client You Can Commit to the Repo
    • API Client Check: Requests, Secrets, and Regression Runsquiz
    • The Node Runtime and the Event Loop: Why Blocking Is the Cardinal Sin
    • HTTP Properly: Methods, Status Codes, Headers and Idempotency
    • Drill: Pick the Right Method, Status Code and Headerfill blank
    • + 4 more lessons
28. 28

    Stage 5 · Validation, Layers and PostgreSQL Access

    7 lessons
    • Validate at the Boundary: Zod Schemas and the Type You Get Back
    • Route, Service, Repository: Deciding What Goes Where
    • Raw SQL with the pg Driver: Placeholders, Rows and the Pool
    • Drill: Boundaries, Layers and Queriesfill blank
    • Transactions: Making a Service Call All or Nothing
    • + 2 more lessons
29. 29

    Stage 5 · Authentication and Authorization

    7 lessons
    • Storing Passwords: Argon2id, and Why Nothing Else Belongs in That Column
    • Sessions or JWTs: The Tradeoff You Have to Be Able to Defend
    • Drill: Cookie Flags, Tokens and Where the Rule Livesfill blank
    • Cookies That Actually Protect the Session: httpOnly, Secure, SameSite
    • Login, Logout and Refresh, End to End in Express and PostgreSQL
    • + 2 more lessons
30. 30

    Stage 5 · Errors, Logging and API Ergonomics

    7 lessons
    • One Error Shape, One Handler
    • Structured Logs You Can Query: Pino, Correlation Ids and Redaction
    • Checkpoint: Error Boundaries and Log Disciplinequiz
    • Pagination, Filtering and Sorting That Stay Consistent
    • Accepting Files Without Regret
    • + 2 more lessons
31. 31

    Stage 5 · OpenAPI, Testing and Security

    7 lessons
    • OpenAPI: Make the Contract a Real Artefact
    • Unit Testing Services with Vitest
    • Integration Tests: Supertest Against a Real Test Database
    • Checkpoint: Contracts and Testsquiz
    • OWASP in Practice: Injection and Broken Access Control
    • + 2 more lessons
32. 32

    Stage 5 · Project: The Production-Style REST API

    7 lessons
    • The Contract Before the Code: Scoping and Scaffolding the API
    • The Skeleton: Typed Config, One Pool, an App Factory and SQL Migrations
    • Checkpoint: The Decisions Behind a Production-Style APIquiz
    • A Vertical Slice: Tasks from Route to SQL, with Search, Filter, Sort and Pages
    • Drill: The Details That Break Buildsfill blank
    • + 2 more lessons
33. 33

    Stage 6 · Capstone 1: Scope, Requirements and Schema

    7 lessons
    • Pick Your Capstone: Four Projects Worth Building
    • Requirements and Acceptance Criteria That Survive Contact With Code
    • Schema First: Model the Workflow in PostgreSQL
    • The API Contract: Agree on Shapes Before the Server Exists
    • Repo, Issues and a Board: Set Up Like a Team of One
    • + 2 more lessons
34. 34

    Stage 6 · Capstone 1: Building the Vertical Slice

    7 lessons
    • Think in Slices, Not Layers
    • Auth and Roles First: Retrofitting Is the Expensive Path
    • One Slice End to End: The Tickets Feature
    • Keeping the OpenAPI Contract and the Client in Step
    • Review Your Own Pull Request First
    • + 2 more lessons
35. 35

    Stage 6 · Capstone 1: Docker, CI and Deployment

    6 lessons
    • Containerise the API: multi-stage Dockerfile
    • Compose: a database that survives restarts
    • CI on every push: lint, typecheck, test, build
    • Deploy: deliberate migrations, real secrets, a demo account
    • Checkpoint: containers, CI and deploymentquiz
    • + 1 more lesson
36. 36

    Stage 6 · Capstone 1: Documentation and Presentation

    7 lessons
    • The README a Hiring Manager Will Actually Read
    • Diagrams as Code: Mermaid Architecture and ER Diagrams
    • API Docs, the Environment Template, and Troubleshooting
    • Design Decisions, Tradeoffs, and Known Limitations
    • The Demo Video Script and the Portfolio Case Study
    • + 2 more lessons
37. 37

    Stage 7 · C# for the TypeScript Developer

    9 lessons
    • Installing the .NET SDK Properly
    • Check: .NET SDK Installationquiz
    • The .NET SDK: One Command That Replaces Your Whole Node Toolchain
    • Projects, Solutions and the Enterprise Repo Layout
    • C# Syntax, Mapped Onto the TypeScript You Already Know
    • + 4 more lessons
38. 38

    Stage 7 · Types, Collections and LINQ

    7 lessons
    • Classes, records and structs: picking the right shape
    • Properties, composition over inheritance, and generics
    • Collections: List, Dictionary, HashSet and IEnumerable
    • LINQ properly: the operators you will actually use
    • Deferred execution: the trap that bites in production
    • + 2 more lessons
39. 39

    Stage 7 · Async, Exceptions and Dependency Injection

    7 lessons
    • Task Is Not a Promise: async and await in C#
    • Checkpoint: Tasks, Threads and Cancellationquiz
    • ConfigureAwait, Synchronization Contexts and Async All the Way Down
    • Exceptions: Throwing, Catching, Custom Types — and When Not To
    • Recall Drill: Async and Exception Vocabularyfill blank
    • + 2 more lessons
40. 40

    Stage 7 · Testing, Configuration and Logging in .NET

    7 lessons
    • xUnit: facts, theories, and the shape of a test project
    • Testing services with fakes instead of heavy mocks
    • Checkpoint: testing services in .NETquiz
    • Configuration: appsettings, environment overrides, and user-secrets
    • Drill: configuration layers and secret handlingfill blank
    • + 2 more lessons
41. 41

    Stage 8 · ASP.NET Core: Pipeline, Controllers, Minimal APIs

    7 lessons
    • The Request Pipeline: Middleware Order Is the Program
    • Controllers and Minimal APIs, Side by Side
    • Checkpoint: Pipeline, Endpoints and Style Choicequiz
    • Routing and Model Binding: Where Values Actually Come From
    • Recall: Routing, Binding and Pipeline Vocabularyfill blank
    • + 2 more lessons
42. 42

    Stage 8 · EF Core and PostgreSQL

    7 lessons
    • Your Node schema, now with a DbContext
    • Migrations with dotnet-ef, on a database that already exists
    • LINQ is not a list: read the SQL it generates
    • Checkpoint: mapping, migrations and generated SQLquiz
    • N+1, Include, projection and AsNoTracking
    • + 2 more lessons
43. 43

    Stage 8 · Validation, Errors and OpenAPI

    7 lessons
    • Failures Need a Shape: Problem Details
    • Two Validators, One Pipeline
    • Checkpoint: Contracts for Failurequiz
    • One Interface, Many Failures: Global Exception Handling
    • Naming the Moving Partsfill blank
    • + 2 more lessons
44. 44

    Stage 8 · Auth, Testing and Security in ASP.NET Core

    7 lessons
    • Who Are You? Authentication, Claims and [Authorize]
    • Policies, Roles and Resource-Based Authorization
    • Checkpoint: Auth, CORS and Test Wiringquiz
    • Unit Testing with xUnit
    • Integration Testing with WebApplicationFactory and Real PostgreSQL
    • + 2 more lessons
45. 45

    Stage 8 · Project: The Same API, Rebuilt — and Compared

    7 lessons
    • Same Schema, New Runtime: Scaffolding the Enterprise API
    • The Request Pipeline: app.use vs app.Use
    • Dependency Injection and Validation: The Container You Never Had
    • Checkpoint: Runtime, Pipeline and Containerquiz
    • Proving It: Tests on Both Stacks and a Benchmark That Survives Review
    • + 2 more lessons
46. 46

    Stage 9 · Angular Foundations: Standalone Components

    7 lessons
    • Angular Is a Framework, React Is a Library: The Mental Model Shift
    • The Angular CLI and the Workspace You Will Inherit
    • Standalone Components, Templates and the Built-in Control Flow
    • Checkpoint: CLI, Workspace and Standalone Componentsquiz
    • Data Binding: Interpolation, Property, Event and Two-Way
    • + 2 more lessons
47. 47

    Stage 9 · Services, DI and Reactive State with Signals

    7 lessons
    • Services and Angular DI: The Container You Already Met in .NET
    • Signals: State That Knows Exactly Who Is Reading It
    • Checkpoint: Injection, Lifetimes and the Signal Primitivesquiz
    • Change Detection in Plain Terms: Zones, OnPush and Zoneless
    • Signals in Services: A Shared Store Without a State Library
    • + 2 more lessons
48. 48

    Stage 9 · RxJS, HttpClient and Interceptors

    7 lessons
    • Observables: the contract Promises never signed
    • switchMap vs mergeMap: winning the typeahead race
    • Checkpoint: the RxJS that mattersquiz
    • HttpClient: typed calls to your enterprise API
    • Interceptors: auth headers and error handling in one place
    • + 2 more lessons
49. 49

    Stage 9 · Routing, Guards and Reactive Forms

    7 lessons
    • The Angular Router: Route Tables, Params and Lazy Loading
    • Route Guards: Auth Walls and Unsaved-Changes Protection
    • Reactive Forms: The Model Lives in the Class
    • Custom Validators, Cross-Field Rules and Accessible Errors
    • Template-Driven Forms, and Why Reactive Is Our Default
    • + 2 more lessons
50. 50

    Stage 9 · Testing, Accessibility and Performance

    7 lessons
    • Component Tests with TestBed: Same Instincts, New Harness
    • Testing Services and HTTP: a Fake Backend in the Injector
    • End-to-End with Playwright: Proving the Whole Stack
    • Accessibility in an SPA: Semantics, Focus and What Scanners Miss
    • Performance: Lazy Routes, Bundle Budgets, track and OnPush
    • + 2 more lessons
51. 51

    Stage 9 · Project: The Enterprise Dashboard Client

    7 lessons
    • Scaffold the Angular Client and Proxy It to Your .NET API
    • Auth: A Functional Interceptor, Route Guards, and Role-Based UI
    • The Orders Table: Server-Side Pagination, Filtering, and Sorting
    • Checkpoint: Interceptors, Guards, and Server-Driven Tablesquiz
    • Reactive Forms: Typed Validation and Mapping Server Errors
    • + 2 more lessons
52. 52

    Stage 10 · Capstone 2: Domain, Requirements and Design

    7 lessons
    • Choose a Domain Worth Defending
    • Model the Workflow, Not Just the Tables
    • Design Authorization Before the First Endpoint
    • Audit History Is a Feature, Not a Log File
    • Acceptance Criteria a Reviewer Can Fail You On
    • + 2 more lessons
53. 53

    Stage 10 · Capstone 2: Building with EF Core and Angular

    7 lessons
    • The Vertical Slice, Round Two: Schema to Tested Feature
    • Server-Side Pagination and Filtering That Scales
    • Complex Angular Forms: Typed Groups, Arrays, and Cross-Field Rules
    • Optimistic Concurrency: xmin, 409s, and What the User Sees
    • Checkpoint: Slices, Scale, and Conflictsquiz
    • + 2 more lessons
54. 54

    Stage 10 · Capstone 2: Operations and Evidence

    7 lessons
    • Compose the Whole System: API, Angular and PostgreSQL with Health Checks
    • CI That Fails Loudly: dotnet test and the Angular Suite on Every Push
    • Structured Logs and Health Endpoints: What You Actually Watch
    • Checkpoint: Operations Under Interrogationquiz
    • Migrations as a Deliberate, Reversible Deployment Step
    • + 2 more lessons
55. 55

    Stage 10 · Capstone 2: Review, Comparison and Case Study

    7 lessons
    • The Clean-Clone Test: Review Your Repo Like a Hiring Manager
    • Do Your Tests Mean Anything? The Mutation Self-Audit
    • The Server-Side Authorization Audit
    • Writing the Honest Stack Comparison
    • Case Study 2, the 90-Second README and Your Primary Stack
    • + 2 more lessons
56. 56

    Stage 11 · Linux, Shell and Docker in Anger

    9 lessons
    • Installing Docker: Desktop or Engine
    • Check yourself: Docker installationquiz
    • The Server Subset of Linux: Processes, Ports and Permissions
    • Reading a Sick Server: Logs, Disk, Environment and Exit Codes
    • Drill: The Command That Answers the Questionfill blank
    • + 4 more lessons
57. 57

    Stage 11 · CI/CD with GitHub Actions

    7 lessons
    • A Pipeline That Earns Trust: Gates Before Deploys
    • Matrix Builds, Caches You Can Reason About, and Artifacts
    • Integration Tests Against a Real PostgreSQL Service Container
    • Pipeline Syntax Drill: Fill In the Missing Piecefill blank
    • Secrets, Token Permissions, and Why They Never Reach the Logs
    • + 2 more lessons
58. 58

    Stage 11 · Deployment, DNS, TLS and CORS

    7 lessons
    • Ship the artefact, not your laptop
    • Managed PostgreSQL and the connection budget
    • Domains, DNS records and TLS that does not expire on you
    • Deployment vocabulary drillfill blank
    • CORS, configured deliberately
    • + 2 more lessons
59. 59

    Stage 11 · Observability, Security and Incidents

    7 lessons
    • Structured Logs and the Correlation Id
    • Health Checks, the Four Numbers, and Profiling Before You Optimise
    • OWASP Top 10, Applied to the Two Apps You Built
    • Supply Chain: Dependency, Secret and Image Scanning in CI
    • Backup, a Tested Restore, and an Incident to Solve
    • + 2 more lessons
60. 60

    Stage 12 · Choosing a Target and Reading the Market

    7 lessons
    • One Seat, Two Stacks: Choosing a Primary Job Identity
    • Reading a Posting: Gate, Required, Wishlist, Noise
    • Checkpoint: Identity, Bands and Honest Claimsquiz
    • The Skills-Gap Matrix: Ten Postings, One Table
    • Level Honesty: Internship, Apprenticeship, Graduate, Junior
    • + 2 more lessons
61. 61

    Stage 12 · Résumé, GitHub and Portfolio

    7 lessons
    • The One-Page Résumé That Actually Parses
    • Bullets That State Action and Result, Per Role Identity
    • Drill: Résumé, Repository and Portfolio Mechanicsfill blank
    • A GitHub Profile That Reads Like Work
    • Portfolio Case Studies and the STAR Worksheet
    • + 2 more lessons
62. 62

    Stage 12 · Interviews: Behavioural and Technical

    7 lessons
    • The 60-Second Introduction That Is Not a Life Story
    • Five STAR Stories Mined From Your Two Capstones
    • Behavioural Questions: What the Interviewer Is Actually Testingquiz
    • The Technical Screen: JavaScript, TypeScript, SQL, React, Angular, Node and .NET
    • Data Structures, Algorithms and System Design at the Level Actually Asked
    • + 2 more lessons
63. 63

    Stage 12 · Applying, Offers and the AI Question

    7 lessons
    • The 30-Day Application Plan: Volume, Targeting and a Tracker You Can Read
    • Messages That Earn Replies: Recruiters, Networking and Referrals
    • Checkpoint: Strategy, Messages, Money and the AI Boundaryquiz
    • Offers: Researching a Range and What Is Negotiable Besides Money
    • The AI Question: Prepare With It, Never Misrepresent With It
    • + 2 more lessons

The shape of it

How this course works