From PHP Syntax to Enterprise CRUD
Back
Beginner Free

From PHP Syntax to Enterprise CRUD

A practical beginner course: from HTTP, PHP runtime, files, and JSON to OOP, Composer, SQL/PDO, tests, Laravel 13, Eloquent, authorization, queues, and Filament admin UI. The cross-cutting project is an NSI management system with products, categories, units, suppliers, users, and roles. The course targets PHP 8.3-8.5, Laravel 13, and Filament 5.

PHP Laravel REST API CRUD Eloquent ORM Filament Admin Authentication Docker-based Development
Go to registration

Course outline

Published version: modules, lessons, and duration.

01

PHP Course Working Environment and Learning Contract

  1. 1 Course Contract and Learning Path
    45 min
  2. 2 Setup Checklist and Tools
    45 min
  3. 3 How to Work Through Lessons and Homework
    45 min
  4. 4 Troubleshooting When Commands Fail
    45 min
  5. 5 Course Boundaries and Final Project Readiness
    45 min
02

HTTP, the Client-Server Model, and the PHP Runtime

  1. 1 What Happens After You Enter a URL in the Browser
    45 min
  2. 2 Client-Server Architecture and Real HTTP Messages
    45 min
  3. 3 HTTP Methods, Status Codes, and Idempotency
    45 min
  4. 4 What the PHP Runtime Is: Interpreter, Compilation, CLI, and the Built-In Web Server
    45 min
  5. 5 The nginx + PHP-FPM Scheme: How the Web Server Hands a Request to PHP
    45 min
03

Basic PHP Syntax and the Execution Model

  1. 1 PHP File, Syntax, Running Code, and Output
    45 min
  2. 2 Variables, Names, Lifetime in a Simple Script, and Constants
    45 min
  3. 3 Primitive Types and Type Casting
    45 min
  4. 4 Strings: Quotes, Interpolation, Concatenation, and Safe Output
    45 min
  5. 5 Runtime Settings, Beginner Errors, and Mini Environment Diagnostics
    45 min
  6. 6 Date/time, Unicode Strings, and Basic Validation
    45 min
04

Conditions, Loops, Arrays, and Functions

  1. 1 Conditions, Comparisons, and Logical Operators
    45 min
  2. 2 Loops: `foreach`, `for`, `while`, `break`, `continue`
    45 min
  3. 3 Indexed Arrays and Basic List Operations
    45 min
  4. 4 Associative and Nested Arrays Using Products as the Example
    45 min
  5. 5 Functions, Parameters, `return`, Anonymous and Arrow Functions
    45 min
  6. 6 Beginner Operators, Scope, and an Overview of Function Types
    45 min
05

Files, JSON, and Procedural Product CRUD

  1. 1 Project Filesystem and Safe Paths
    45 min
  2. 2 Reading and Writing Files in PHP
    45 min
  3. 3 JSON: `json_encode`, `json_decode`, Errors, and Data Structure
    45 min
  4. 4 Procedural CRUD Functions for Products
    45 min
  5. 5 HTTP Endpoint for a Product API Without a Framework
    45 min
  6. 6 Validation, Errors, and Scenario Checks Through `curl`
    45 min
  7. 7 Manual Includes and Request Input Map
    45 min
06

Debugging, HTTP Tools, and the Beginner's Workflow

  1. 1 How a Beginner Should Read PHP Errors and HTTP Responses
    45 min
  2. 2 Xdebug: Installing It in the Environment, Breakpoints, and Step Debugging
    45 min
  3. 3 `curl` as a Precise HTTP Checking Tool
    45 min
  4. 4 Postman: Collections, Variables, and Positive/Negative Scenarios
    45 min
  5. 5 The Workflow from Bug Report to Fix
    45 min
07

OOP Foundations: Objects, Messages, State, and Behavior

  1. 1 The Historical Meaning of OOP and Alan Kay's Idea
    45 min
  2. 2 Classes and Objects in PHP: State, Behavior, Instances
    45 min
  3. 3 Encapsulation and Information Hiding Without Myths
    45 min
  4. 4 Abstraction and Object Responsibility
    45 min
  5. 5 Inheritance: When It Is Useful and When It Is Dangerous
    45 min
  6. 6 Polymorphism, Messages, and Reuse in a Small CRUD
    45 min
08

OOP Design, Interfaces, Abstract Classes, and CRUD Architecture

  1. 1 Interfaces as Behavior Contracts
    45 min
  2. 2 Abstract Classes: Shared Code and Required Extension Points
    45 min
  3. 3 Interface vs Abstract Class: Practical Choice
    45 min
  4. 4 Product Entity and Value Objects
    45 min
  5. 5 Repository, Service, Controller, and DTO
    45 min
  6. 6 Exceptions, Manual DI, and Assembling a CRUD Scenario
    45 min
  7. 7 Overengineering: Where to Stop
    45 min
  8. 8 PHP OOP Syntax That Laravel Will Use Later
    45 min
09

Composer, Autoload, PSR, and the Package Ecosystem

  1. 1 Composer as the Entry Point into a Modern PHP Project
    45 min
  2. 2 `composer.json`, Dependencies, `vendor/`, and `composer.lock`
    45 min
  3. 3 Autoload, Namespace, and `PSR-4`
    45 min
  4. 4 PSR Standards: Style, Autoloading, and HTTP Interfaces
    45 min
  5. 5 Packagist, Semver, Updates, and Composer Scripts
    45 min
10

SQL, the Relational Model, and First Queries

  1. 1 Set Up the Training Database and Run the First SQL
    45 min
  2. 2 Relational Model: Tables, Rows, Columns, Keys, and Relations
    45 min
  3. 3 Reading Data: `SELECT`, `WHERE`, `ORDER BY`, `LIMIT`
    45 min
  4. 4 Changing Data: `INSERT`, `UPDATE`, `DELETE`
    45 min
  5. 5 Relations and `JOIN`
    45 min
  6. 6 Aggregates and Grouping
    45 min
  7. 7 Indexes, Constraints, Transactions, and Data Integrity
    45 min
11

PDO, bindings, SQL injection, and repository on top of the database

  1. 1 PDO connection: DSN, drivers, error mode
    45 min
  2. 2 `prepare` and `execute`: placeholders and fetch modes
    45 min
  3. 3 `bindValue` and `bindParam` on `INSERT`, `UPDATE`, `DELETE`
    45 min
  4. 4 SQL injection: dangerous example, safe example, and whitelist
    45 min
  5. 5 Moving Product CRUD from JSON to the Database Through a Repository
    45 min
  6. 6 Transactions and Error Handling in a Repository
    45 min
12

Testing, debugging, and quality before Laravel

  1. 1 PHPUnit or Pest: installation, test structure, and Composer scripts
    45 min
  2. 2 Unit tests: checking pure business logic without the database
    45 min
  3. 3 Integration tests: checking a PDO repository on a test database
    45 min
  4. 4 Fixtures and factories before Laravel
    45 min
  5. 5 Debugging: errors, stack trace, `var_dump`, logs, and Xdebug as the next step
    45 min
  6. 6 Coding standard and maintainability: PHP-CS-Fixer, Pint, and project commands
    45 min
13

Laravel Foundation: Lifecycle, Routing, and MVC

  1. 1 Installing Laravel 13 and Running the Application for the First Time
    45 min
  2. 2 Project Structure, `.env`, `config`, and `artisan`
    45 min
  3. 3 Request Lifecycle: from `public/index.php` to `Response`
    45 min
  4. 4 Routes as the Application HTTP Contract
    45 min
  5. 5 Controllers and MVC Without Myths
    45 min
  6. 6 Service Container, Service Providers, and Minimal Laravel Diagnostics
    45 min
  7. 7 Request and Response: Input, Output, and Redirects
    45 min
  8. 8 Facades and Helpers: Convenient Access to Laravel Services
    45 min
  9. 9 Blade, Views, and Forms: the Minimum Before Auth and Filament
    45 min
14

Laravel database, Eloquent, validation, and API

  1. 1 Database connection and reference table migrations
    45 min
  2. 2 Eloquent models, mass assignment, casts, and basic queries
    45 min
  3. 3 Model relationships, factories, and seeders
    45 min
  4. 4 Form Request validation and a clear error contract
    45 min
  5. 5 API controllers, API Resources, pagination, filters, and sorting
    45 min
  6. 6 Performance and data integrity: `N+1`, eager loading, scopes, and transactions
    45 min
  7. 7 Query Builder as a bridge from SQL/PDO to Eloquent
    45 min
  8. 8 Laravel Collections and Eloquent Collections
    45 min
  9. 9 Laravel testing: HTTP feature tests, factories, and JSON assertions
    45 min
15

Laravel Infrastructure: Auth, Session, Cache, Queues, and Packages

  1. 1 Runtime, Nginx, PHP-FPM, and Production Thinking
    45 min
  2. 2 Sessions, Cookies, CSRF, and Authentication
    45 min
  3. 3 Authorization, Policies, Gates, Sanctum, and Roles
    45 min
  4. 4 Cache, Invalidation, and Rate Limiting
    45 min
  5. 5 Queues, Jobs, Events, Mail, and Notifications
    45 min
  6. 6 Storage, Uploads, Logging, and Diagnostics
    45 min
  7. 7 Composer Packages, Ecosystem, and PSR
    45 min
  8. 8 Error Handling, Debug Mode, and Production Responses
    45 min
  9. 9 Deployment Checklist and Operational Thinking
    45 min
16

Filament admin, enterprise CRUD, and the final project

  1. 1 Installing Filament, panel provider, and the first admin user
    45 min
  2. 2 Resources for NSI: categories, units, suppliers
    45 min
  3. 3 ProductResource: forms, Select relationships, validation, and casts
    45 min
  4. 4 Tables: columns, search, sorting, filters, row actions, and bulk actions
    45 min
  5. 5 Relations, policies, and a safe admin area
    45 min
  6. 6 Enterprise CRUD polish: operator UX, imports overview, notifications, audit thinking
    45 min
  7. 7 Final project: admin + API + Docker/Git workflow + readiness criteria
    45 min