Prowid logo — programming courses PROWIDIT Education Academy

Full Stack Developer

Full Stack course — Prowid
Course duration
10 months / 80 lessons
Individual
Per month 200 AZN
Group
Per month 150 AZN
Paying for the full course in a group
15% discount
Installments
50/50
Subscription
from 30 AZN a month
A Full Stack developer builds the whole application: user interface, API, database and server deployment. The course is built on the most in-demand TypeScript stack — React, Next.js, Node.js, PostgreSQL and Docker. Suitable for complete beginners.

Enrollment for a new group is open — send a request to reserve your seat

Lessons are taught live in Azerbaijani and Russian.

Enroll in the course Free trial lesson

Or study on your own in your personal account → with a subscription from 30 AZN a month

Course curriculum

How the web works: HTTP, browser, server, DNS; dev environment — VS Code, terminal, DevTools
Git and GitHub: commits, branches, Pull Requests, code review
HTML5 and CSS3: semantic markup, Flexbox, Grid, responsive design, Tailwind CSS
Modern JavaScript: functions, objects, arrays, modules, DOM
Asynchronous JavaScript: Promise, async/await, REST APIs with fetch
TypeScript: types, generics, validation with Zod — one language for frontend and backend
React 19: components, hooks, forms, React Router
Server and global state: TanStack Query, Zustand; shadcn/ui components
Node.js and Express: REST API design, middleware, error handling, OpenAPI (Swagger)
NestJS: modules, controllers, services, dependency injection, DTO validation
SQL and PostgreSQL: queries, JOINs, indexes, transactions, database design
Prisma ORM: schema, migrations, relations; caching with Redis
Authentication and authorization: sessions, JWT, OAuth 2.0 (sign in with Google/GitHub), roles
Web security: OWASP Top 10, XSS, CSRF, CORS, rate limiting
Next.js (App Router): Server Components, Server Actions, SSR/SSG, SEO
Real-time features and files: WebSocket (Socket.io), notifications, file uploads
Testing: Vitest, React Testing Library, Supertest, Playwright (E2E)
Docker and Docker Compose, CI/CD with GitHub Actions, deployment: VPS and Vercel, monitoring
AI-assisted development: Copilot, Cursor, Claude Code; integrating LLM APIs into your app
System design basics: monolith vs microservices, caching, queues, scaling
Final project: a full-stack SaaS application, portfolio and technical interview prep

You can also take the modules as separate courses: HTML & CSS, JavaScript, TypeScript, React, Next.js, Node.js, SQL, Git, Docker, AI.

How do we teach?

Learning stages

01

Webinar

Students join the lesson live. At the end of each lesson, students are sent a video recording of the class.

02

Homework

Every assignment is based on the topic covered in the webinar. Homework helps you reinforce the material and understand it better.

03

Working with a mentor

The teacher stays in touch with the group both during the course and outside class. Any questions get answered right away.

04

Portfolio

During the course you'll complete several projects on different topics — they'll show employers what you can do.

Self-paced learning

The full curriculum in your personal account

270 topics with theory, examples and practice. 24 of them are free (marked in the program), the rest come with a subscription. Interactive lessons with slides and coding trainers: 209.

Start for free Subscription from 30 AZN a month
Getting Started: the Web, Tools and Git16 topics
  1. How the Web Works: Browser, Server, HTTP, Domain and Hosting
  2. Dev Environment: VS Code, Extensions, Live Server and Emmet
  3. Browser DevTools: Element Inspector, DOM and Device Mode
  4. What Version Control Is and Why Git
  5. The Terminal on Windows, macOS and Linux: First Steps
  6. Installing Git on Windows, macOS and Linux
  7. git init: Creating Your First Repository
  8. Git's Three Areas: Working Tree, Index and Repository
  9. git commit: Recording a Snapshot of the Project
  10. .gitignore: Files That Should Stay Out of Git
  11. Creating and Switching Branches: git switch
  12. Merge Conflicts: Resolving Step by Step
  13. Your GitHub Account and First Repository on the Site
  14. git push and Upstream Branches
  15. Pull Requests: Proposing Changes
  16. Code Review on GitHub
HTML and CSS22 topics
  1. Your First HTML Page: Tags, Elements, Attributes and Nesting
  2. HTML Document Structure: doctype, html, head and body
  3. Links: the a Tag, href, Absolute and Relative Paths
  4. Semantic Markup: header, nav, main and footer Instead of div
  5. Forms: form, action, method, name and Submit Buttons
  6. Accessibility (a11y): WCAG, Screen Readers and Alt Text
  7. SEO Basics: title, meta description, canonical, robots and hreflang
  8. What CSS Is and How to Add It: style, link and Inline Styles
  9. Basic Selectors: Type, Class, ID, Universal and Grouping
  10. Selector Specificity: How to Calculate and Manage It
  11. The Box Model: content, padding, border, margin and box-sizing
  12. Positioning: position relative and absolute, the inset Property
  13. Introduction to Flexbox: Flex Container, Items and Axes
  14. Flexbox Patterns: Navbar, Cards, Sticky Footer and Media Object
  15. Introduction to CSS Grid: Lines, Tracks, Cells and Areas
  16. Grid Layouts: Holy Grail, Gallery, Magazine Grid and Overlapping
  17. Media Queries: @media Syntax, Types and Logical Operators
  18. Mobile-first and Choosing Breakpoints
  19. CSS Custom Properties: Declaration, Scope and Fallbacks
  20. Tailwind CSS v4: the Utility-first Approach and Setup
  21. Tailwind Utilities: Spacing, Typography, Colors, Flexbox and Grid
  22. Project: Landing Page Sections with Tailwind CSS
JavaScript30 topics
  1. What JavaScript Is and Where It Runs
  2. Variables: let, const and Naming Rules
  3. Data Types and the typeof Operator
  4. Conditionals: if, else if and else
  5. The for Loop: Counters, Steps and Nested Loops
  6. Function Declarations: Parameters, Arguments and Calls
  7. Arrow Functions
  8. Callbacks and Higher-Order Functions
  9. Closures: How Functions Remember Their Scope
  10. Objects: Literals, Properties, Dot and Bracket Notation
  11. Object Destructuring
  12. Arrays: Creation, Indexes, length and at()
  13. map and filter: Transforming and Filtering Arrays
  14. reduce: Folding an Array into a Single Value
  15. JSON: JSON.stringify and JSON.parse
  16. Classes: constructor, Methods and Fields
  17. Handling Errors: try, catch and finally
  18. Selecting Elements: querySelector, getElementById, closest
  19. Event Listeners: addEventListener and removeEventListener
  20. Form Events: submit, input, change and FormData
  21. localStorage and sessionStorage: Storing Data in the Browser
  22. The Event Loop: Call Stack and Task Queue
  23. Promises: States, then, catch and finally
  24. async/await: Writing Async Code in a Synchronous Style
  25. GET Requests with fetch: Response, json() and URLSearchParams
  26. Sending Data: POST, PUT, PATCH and DELETE
  27. ES Modules: import and export
  28. npm: package.json, Dependencies and Scripts
  29. Frontend Security: XSS, innerHTML vs textContent
  30. Project: Weather App Using a Public API
TypeScript14 topics
  1. Why TypeScript: Static Typing on Top of JavaScript
  2. Installing TypeScript and Running the tsc Compiler
  3. Strict Mode and Additional Compiler Checks
  4. Type Annotations: Variables, Parameters and Return Values
  5. Type Inference: let vs const, Widening and Contextual Typing
  6. Object Types and Optional Properties
  7. Union Types: A Value of One of Several Types
  8. Discriminated Unions: Using a Shared Tag Field
  9. Interfaces: Describing the Shape of an Object
  10. Function Types: Type Expressions and Call Signatures
  11. Why Generics: From any to Type Parameters
  12. Pick, Omit and Record: Selecting Keys and Building Dictionaries
  13. Zod: Schemas, parse/safeParse and z.infer
  14. Project: A Typed API Client
React21 topics
  1. What React Is and Why Use It
  2. JSX: Markup in JavaScript and Curly-Brace Expressions
  3. Function Components: Creating, Nesting, Importing and Exporting
  4. Props: Passing Data to Components
  5. Conditional Rendering: if, Ternary and &&
  6. Rendering Lists and Keys
  7. The useState Hook: Component State
  8. Lifting State Up and a Single Source of Truth
  9. Controlled Inputs: input and textarea
  10. useEffect: Synchronizing with External Systems
  11. You Might Not Need an Effect: Common Anti-patterns
  12. Context API: Passing Data Without Prop Drilling
  13. Custom Hooks: Extracting and Reusing Logic
  14. React Router v7: Setup, Modes and First Routes
  15. Protected Routes and Redirects
  16. TanStack Query: Server State and Your First useQuery
  17. Mutations: useMutation and Cache Invalidation
  18. Zustand: A Simple Global Store
  19. Typing Props and Children
  20. React Hook Form + Zod: zodResolver and Error Messages
  21. Project: CRUD Notes App with TanStack Query
Node.js and Express: REST APIs17 topics
  1. What Is Node.js: V8, libuv and Server-Side JavaScript
  2. The Node.js Event Loop and Non-Blocking I/O
  3. ES Modules in Node.js: import, export and the type Field
  4. Environment Variables and .env: --env-file and process.loadEnvFile
  5. How HTTP Works: Requests, Responses, Methods, Headers and Statuses
  6. Getting Started with Express 5: Your First App
  7. Routing in Express: Methods, Paths and express.Router
  8. Express Middleware: The Request Processing Chain
  9. Error Handling in Express 5
  10. Express Project Structure: Routes, Controllers and Services
  11. REST Principles: Resources, URLs and Method Semantics
  12. Status Codes and a Consistent Error Format in APIs
  13. Pagination, Filtering and Sorting in REST APIs
  14. Validating Express Requests with Zod Middleware
  15. Documenting APIs: OpenAPI and Swagger UI
  16. A Typed Express API with TypeScript
  17. Project: Notes REST API with Express
Databases: SQL, PostgreSQL, Prisma and Redis23 topics
  1. What Is a Database and a DBMS
  2. The Relational Model: Tables, Rows, Columns and Keys
  3. Running PostgreSQL and MySQL in Docker
  4. Creating a Database, a Schema and Your First Table
  5. Foreign Keys: Linking Tables
  6. INSERT: Adding One or Many Rows
  7. SELECT: Columns, Expressions and Aliases
  8. WHERE: Comparison Operators and AND, OR, NOT
  9. GROUP BY: Grouping Rows
  10. INNER JOIN: Combining Related Tables
  11. LEFT JOIN: Keeping All Rows from the Left Table
  12. One-to-Many and One-to-One Relationships
  13. Many-to-Many Relationships and Junction Tables
  14. How Indexes Work: B-Tree and CREATE INDEX
  15. Transactions: BEGIN, COMMIT, ROLLBACK and SAVEPOINT
  16. SQL Injection: How the Attacks Work
  17. Prisma ORM: Setup and Defining the Data Schema
  18. Prisma Migrations and Seeding the Database
  19. CRUD Queries in Prisma: Filtering, Sorting and Pagination
  20. Relations in Prisma: One-to-Many, Many-to-Many and One-to-One
  21. Transactions and Error Handling in Prisma
  22. Redis: Caching Responses and Data
  23. Project: Blog API with PostgreSQL and Prisma
Authentication and Security12 topics
  1. Authentication and Authorization: Core Concepts and Approaches
  2. Storing Passwords: bcrypt, Sign-Up and Login
  3. Cookies and Sessions: express-session and Session Stores
  4. JWT: Token-Based Authentication and Protecting Routes
  5. Access and Refresh Tokens: Rotation, Logout and Revocation
  6. Authorization: Roles, Permissions and Resource Ownership
  7. OAuth 2.0 and Sign-In with Google
  8. Helmet and Security Headers
  9. CORS: How It Works and How to Configure It Properly
  10. Rate Limiting: Protection Against Brute Force and Overload
  11. OWASP Top 10 for Node.js: Injections, XSS and Untrusted Input
  12. Project: JWT Authentication Service
Files, Background Jobs and Real Time6 topics
  1. File Uploads in Express: multer
  2. Image Processing with sharp and S3 Cloud Storage
  3. Background Jobs and Queues with BullMQ
  4. Real-Time on the Web: Polling, Server-Sent Events and WebSocket
  5. Socket.IO: Events, Acknowledgements and the Client
  6. Project: Real-Time Chat with Socket.IO
NestJS3 topics
  1. Getting Started with NestJS: Modules, Controllers and Providers
  2. NestJS: DTOs and Validation, Pipes, Guards and Interceptors
  3. NestJS: Configuration, Prisma and Swagger
GraphQL11 topics
  1. What GraphQL Is and Why: Comparison with REST
  2. GraphQL Schema and Types: SDL, Scalars, Object Types, Non-Null
  3. Queries: Arguments, Variables, Aliases and Fragments
  4. Mutations: Creating, Updating and Deleting Data
  5. Apollo Server: Your First GraphQL Server in Node.js
  6. Resolvers and the Database: parent, args, context and Prisma
  7. The N+1 Problem and Batching with DataLoader
  8. Authentication, Errors and Security in GraphQL
  9. Apollo Client in React: useQuery, useMutation and the Cache
  10. Pagination and Subscriptions: Cursors, Relay Connections, Real Time
  11. Project: A Blog with a GraphQL API and a React Client
Next.js23 topics
  1. What Next.js Adds to React
  2. Creating a Project with create-next-app
  3. File-Based Routing: Folders, page.tsx and Nested Routes
  4. Layouts: Root and Nested Layouts
  5. Dynamic Segments: [id] and Async params
  6. Error Handling: error.tsx and global-error.tsx
  7. Server Components: Components That Run on the Server
  8. The 'use client' Directive and Client Boundaries
  9. UI Components: shadcn/ui, cn() and Variants with cva
  10. Fetching Data in Server Components
  11. Streaming with Suspense: Rendering a Page in Parts
  12. Route Handlers: API Endpoints in the app Folder
  13. How Caching Works in Next.js
  14. PostgreSQL and Prisma: Connecting to a Project
  15. Data Access Layer: DAL, DTO and React cache()
  16. Server Actions: The 'use server' Directive and Forms
  17. Data Mutations: Server Actions, revalidatePath and redirect
  18. Server-Side Form Validation with Zod
  19. Server Actions Security
  20. Auth.js v5: Setup and Sign-In with GitHub
  21. Protecting Routes: Proxy, DAL and Server Actions
  22. Metadata API: Titles, Descriptions and Open Graph
  23. Project: Full-Stack Task Manager with Server Actions
tRPC4 topics
  1. What tRPC Is: End-to-End Type Safety Without a Schema
  2. tRPC Server: Routers, Procedures, Zod Input and Middleware
  3. tRPC Client: React Query Integration and Next.js
  4. Project: A Notes App with Next.js, tRPC and Prisma
Online Payments (Stripe)6 topics
  1. How Online Payments Work: Acquiring, Payment Gateways, 3-D Secure and PCI DSS
  2. Stripe Checkout: Products, Prices and the Payment Page
  3. Stripe Webhooks: Verifying Signatures and Updating Orders
  4. Payment Intents and the Payment Element: Your Own Payment Form
  5. Subscriptions with Stripe: Recurring Payments and the Customer Portal
  6. Project: Order Checkout for an Online Store (Next.js, Prisma, Stripe)
Testing6 topics
  1. Vitest: Setup and First Tests
  2. React Testing Library: Rendering and Querying Elements
  3. Async Tests and Mocking APIs with MSW
  4. API Integration Tests with supertest
  5. Testing with a Database: Test DB, Fixtures and Isolation
  6. End-to-End Tests with Playwright
Docker, CI/CD and Deployment16 topics
  1. What Problems Docker Solves
  2. Your First Container: docker run and Its Key Flags
  3. Your First Dockerfile: FROM, RUN, COPY, CMD and docker build
  4. Multi-Stage Builds: Separate Build and Runtime
  5. Volumes: Keeping Container Data Safe
  6. Docker Compose: Your First compose.yaml and Core Commands
  7. Project: App + PostgreSQL + Redis with Docker Compose
  8. Dockerizing Node.js: A Production Image for Express and NestJS
  9. Deploying to Vercel
  10. First Deployment: Running a Compose Project on the Server
  11. Nginx as a Reverse Proxy for Containers
  12. HTTPS with Let's Encrypt: certbot and Auto-Renewal
  13. CI for a Project: Tests and Linters on Every Pull Request
  14. Automatic Deployment to a VPS over SSH
  15. Logging and Error Monitoring: instrumentation.ts and Sentry
  16. Why Kubernetes: Orchestration and Cluster Architecture
Message Brokers and Event-Driven Architecture7 topics
  1. Synchronous vs Asynchronous Communication: Queues, Pub/Sub and Brokers
  2. RabbitMQ Basics: Exchanges, Queues, Acks and Your First Producer/Consumer
  3. RabbitMQ: Exchange Types, Routing and Dead-Letter Queues
  4. Apache Kafka Basics: Topics, Partitions and Offsets
  5. Kafka: Consumer Groups, Ordering and Processing Guarantees
  6. Event-Driven Architecture: Idempotency, the Outbox and Sagas
  7. Project: Order Events — Notification and Inventory Services on RabbitMQ
Monorepos4 topics
  1. What a Monorepo Is: Monorepo vs Polyrepo and Structure
  2. pnpm Workspaces: Shared Packages and Dependencies
  3. Turborepo: Task Graph, Caching and Faster CI
  4. Project: A Full-Stack Monorepo with Next.js, an API and Shared Packages
AI in Development10 topics
  1. AI for Developers: What an LLM Is and What You Will Learn
  2. GitHub Copilot: Completions, Chat and Agent Mode
  3. Claude Code: An Agentic Coding Tool in the Terminal
  4. Reviewing AI-Generated Code
  5. Security of AI-Generated Code
  6. Your First Request with an SDK in Python and JavaScript
  7. Streaming: Showing the Response as It Is Generated
  8. Typed Responses: Pydantic and Zod
  9. Chat UI: Messages, Markdown and States
  10. RAG: Giving a Model Knowledge from Your Documents
System Design11 topics
  1. Introduction to System Design: Requirements, Latency, Throughput and Estimates
  2. Scaling: Vertical vs Horizontal, Stateless Services
  3. Load Balancing: Algorithms, Health Checks and Nginx
  4. Caching and CDNs: Cache Layers, Cache-Aside, TTL and Invalidation
  5. Scaling Databases: Replication, Partitioning and Sharding
  6. SQL vs NoSQL, the CAP Theorem and Consistency Models
  7. Monolith, Modular Monolith and Microservices: What to Choose and When
  8. Reliability: Timeouts, Retries, Circuit Breakers and Idempotency
  9. Observability: Logs, Metrics, Traces, SLIs and SLOs
  10. Workshop: Designing a URL Shortener
  11. Workshop: Designing a Chat and Notification System
Teamwork: Agile and Scrum4 topics
  1. What Agile Is: Iterative Development and the Agile Manifesto
  2. Scrum: Roles, Sprints, Events and Artifacts
  3. Kanban, User Stories, Acceptance Criteria and Estimation
  4. A Developer's Workflow in a Team: From Ticket to Deploy
Final Project4 topics
  1. Final Project: Idea, Architecture and Data Schema
  2. Final Project: Building the Core Features
  3. Final Project: Testing, Optimization, Deployment and Presentation
  4. Final Project: A Full-Stack App in Production

Group and individual classes include a teacher, homework review and a certificate. The subscription gives you materials, exercises and progress tracking at your own pace, without teacher feedback.

Full Stack Developer course: how to enroll

Fill in the form and we will tell you the start date of the next group, the schedule and payment terms. Or come to a free trial lesson first.

+994 77 333 38 36 Or message us on WhatsApp right away info@prowid.com

By submitting the form, you agree that your data will be used only to contact you.

WhatsApp