CF

PHP Symfony 4 API Platform + React.js Full Stack Masterclass

19h 24m 17s
English
Paid
Updated September 2026

PHP Symfony 4 API Platform + React.js Full Stack Masterclass is a 220-lesson 19 hours 24 minutes self-paced course by Udemy. Modern web development almost always means shipping a backend API alongside a separate front-end app, and this course walks through building exactly that pairing: a Symfony 4 API Platform backend with a React.

Course facts

Lessons
220
Duration
19 hours 24 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
Udemy
Price
Premium

Modern web development almost always means shipping a backend API alongside a separate front-end app, and this course walks through building exactly that pairing: a Symfony 4 API Platform backend with a React.js front end.

Building the API

You build a blog application's API using Symfony controllers and routing, then use Doctrine to represent database tables as objects and convert that model into a working API through API Platform.

Building the Frontend

On the client side, you build a full React app using Redux and Redux-Form to consume that API, plus configure an admin panel for managing the platform's content.

No prior framework experience is required, setup is covered for both Windows and macOS, including installing PHP and Node.js, so you can start from scratch and come away comfortable with the whole PHP-to-React pipeline.

This is where I can help you. Take this course to learn how to create robust APIs in PHP, using Symfony Framework 4 and API Platform. You will not believe how easy and instant it could be! I'll take you step by step during the whole process, from creating your own robust API to making a modern React.JS application using Redux, Redux-Form and all the other tools that you just need to know to get a job these days! You will be creating a Blog application, starting with the API in Symfony API Platform, and then a complete React+Redux frontend app. We will also configure an administration panel for managing the platform. Both Windows and MacOS are supported (I'll show you how to install and configure PHP and Node.js on both)

What will you learn about Symfony and API Platform?

You will learn how to create Symfony controllers and work with routing

You will learn how to represent your database tables as objects in Doctrine

You will see how you can quickly convert your Doctrine model to an API Resource

You will learn how to paginate, filter and sort your collections

You will see how to send an e-mail

You will learn everything about Authentication (user sign-up, sign-in, including account confirmation through e-mail)

You will understand everything about Authorization (User roles, privileges, restricting access)

You will know how to handle file uploads through REST API

You will learn how to log errors

You will learn both unit testing (PHPUnit) and functional testing (Behat)

You will know how to customize and extend the built-in operations that API Platform provide

Data validation and serialization/deserialization

What will you learn about React.js?

How to configure routes for your app using React Router

How to handle state with Redux

How to create great forms using Redux Forms

Communicating with the API using Thunk Middleware

After finishing this course you will be able to confidently create your own complicated APIs in Symfony using API Platform and create a SPA application using React.js!

What you'll learn:

  • You will know how to create a robust APIs in Symfony 4 using API Platform
  • You will understand the basics of Symfony Framework
  • You will know how to create a pretty complicated ReactJS application that works with API Platform (or any API!)

Requirements:

  • Any code editor
  • Some previous PHP exposure would be very useful (this course does not teach PHP from the very basics!)
  • JavaScript basics for the React part

Who teaches PHP Symfony 4 API Platform + React.js Full Stack Masterclass? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in PHP Symfony 4 API Platform + React.js Full Stack Masterclass?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 220 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (220)
#Lesson TitleDurationAccess
1
Introduction Demo
06:46
2
Course outline and how to make most of this course! (PLEASE WATCH!)
09:29
3
Tools (required/optional) overview
08:36
4
Installing PHP and Composer on Windows
05:50
5
Installing PHP and Composer on Mac
01:52
6
Installing Visual Studio Code
01:19
7
Namespaces
04:43
8
Class Fields and Methods
05:47
9
Method & Field Visibility
05:14
10
Inheritance
10:42
11
Abstract Classes
03:40
12
Interfaces
11:16
13
Typed Arguments & Function Return Types
12:29
14
Anonymous Functions (Closures)
04:49
15
Reflection API (Reverse-Engineer Classes, Methods, Functions)
05:05
16
Dependency Injection (In Practice)
05:47
17
Simple Service Container (Hands-On Coding!)
12:30
18
Service Autowiring Implementation Part 1
10:52
19
Service Autowiring Implementation Part 2
11:25
20
Annotations and Kernel Part 1
08:05
21
Annotations and Kernel Part 2
12:41
22
Creating new Symfony project
01:25
23
Routing annotations in controllers
02:47
24
Routing - route parameter wildcards
05:33
25
Routing - default parameter values
02:24
26
Routing - generating urls using route names
01:58
27
AbstractController, Request, Response
04:39
28
Installing ORM, maker, configuring database
02:10
29
Generating first Entity
03:17
30
Entity explained
02:31
31
Migration - modifying database structure
02:59
32
Persisting entities and serializing data
05:15
33
Fetching objects using repositories
03:22
34
ParamConverter - type hinting actions for automatic fetching of entities
06:00
35
Deleting entities
03:40
36
Doctrine Fixtures - seeding fake data
04:52
37
Admin panel introduction - EasyAdmin
03:15
38
Install API Platform and create the first resource
06:20
39
Generate User and Comment entity
02:19
40
ManyToOne relation and migration
09:13
41
Fixtures with references (for relations)
05:34
42
Password encoding in fixtures
04:02
43
Generate fake data in fixtures using Faker
07:56
44
BlogPost with Comment relation and fixtures
04:45
45
Built-in API Platform operations
05:42
46
Disabling operations
03:13
47
Introduction to serialization/deserialization
04:34
48
Serialization groups (controlling which properties are serialized)
02:16
49
EventSubscriber (hashing password)
06:51
50
Validator and validation constraints
04:44
51
Validation using regular expressions
04:30
52
Virtual property (not persisted to database)
02:58
53
Validating uniqueness of fields (username, email)
02:03
54
JWT Tokens introduction
05:26
55
Preparing JWT token library and keys
03:25
56
Configuring UserProvider
04:25
57
Firewall configuration
08:39
58
JSON login configuration and Guard Authentication explained
06:11
59
Authentication final configuration and first login using JWT token
05:43
60
Using is_granted() to control access to operations
02:56
61
BlogPost validation on POST
06:17
62
Setting author of BlogPost automatically (EventSubscriber)
08:16
63
Making sure only owner of BlogPost can modify it (PUT)
06:08
64
Controlling which properties can be changed (no username change)
06:45
65
Hasing password on User changes (PUT) - with Events
07:08
66
Comment resource operations (POST/PUT)
05:09
67
More randomness in fixtures
07:23
68
Setting author automatically (EventSubscriber) - using generic Interface
05:59
69
Setting published date automatically (EventSubscriber)
07:11
70
API subresources
05:20
71
Controlling how deep relations are serialized
07:44
72
Embedding Author resource inside BlogPost
04:10
73
Adding user role field with migration
05:48
74
User role fixtures
09:27
75
Defining role hierarchy
01:41
76
Verifying only users with specific role can POST resources
09:44
77
Different User view for admins (different serialization of all User entities)
09:21
78
Verifying only admin can see all User's email
03:03
79
User can view his full profile (including email and roles) - custom Normalizer
11:17
80
Verifying only the profile owner can see all properties
01:26
81
Disabling password hashing for PUT operation
05:53
82
Configuring custom operation for password reset in User
02:21
83
Creating custom Action class
10:32
84
Implementing custom PasswordReset action
08:36
85
Invalidating JWT tokens after password reset
11:18
86
User enabled property migration and fixtures
05:17
87
Implementing UserChecker to verify if account is enabled
03:51
88
Secure confirmation token generation
05:43
89
Generating confirmation token when user signs-up
04:35
90
UserConfirmation custom API Resource
03:36
91
UserConfirmation EventSubscriber
06:39
92
Verifying Confirmation Token endpoint
02:49
93
Install and configure Swift Mailer
03:50
94
Sending a test e-mail through Gmail
02:18
95
Refactoring UserConfirmation and Mailer into services
08:26
96
Traditional (non API) account confirmation route (for e-mail)
04:57
97
Verifying confirmation link received in e-mail
02:06
98
Install and configure uploading library
04:04
99
Image entity with migration and @Uploadable annotation
05:13
100
API Resource for Image entity
02:49
101
Implementing custom Action for upload
05:51
102
Creating Form for file upload
05:38
103
Assigning Image to BlogPost (ManyToMany relation)
04:00
104
Verifying assigning Image to BlogPost, embedding Image inside BlogPost
04:22
105
Configuring default collection sorting order
03:34
106
Search filter
06:40
107
Date filter
04:32
108
Range filter
02:06
109
Sorting filter
04:26
110
Filtering by nested properties
02:04
111
Property filter
03:00
112
Configuring collection pagination
06:07
113
Configuring collection pagination part 2
04:36
114
Partial pagination (performance gain)
01:46
115
Empty request body for POST/PUT requests problem
02:58
116
Handling empty request body
06:25
117
Fixing validation groups
01:57
118
Handling business logic exceptions
03:51
119
Installing Monolog library for application logging
07:56
120
Defining custom logging channel
04:32
121
Logging to separate files per channel
02:42
122
Production configuration for logger explained
03:39
123
EasyAdmin basic built-in features
07:02
124
Fixing empty body subscriber for form submittal
04:18
125
Custom Resource controller, customizing saving and updating an Entity
08:21
126
Image upload in admin panel
03:58
127
Custom page for individual BlogPost
05:27
128
Securing Admin panel area
06:07
129
Installing PHPUnit and writing first basic unit test
07:06
130
Testing EventSubscriber static configuration
04:27
131
Mocks (stubs) Part 1 - Mocking dependencies, Entities
05:32
132
Mocks (stubs) Part 2 - Mocking dependencies, Entites
05:10
133
Event class Mock, extracting repeated mock factory code
03:29
134
Parameters for mocks
04:50
135
Full test for AuthoredEntitySubscriber
06:38
136
Data providers in tests (using many data sets in 1 test case)
04:43
137
Finding potential errors using unit tests (null Token example)
05:46
138
Installing Behat & all extensions, first suite run
03:00
139
Configuring Behat
04:52
140
FeatureContext - creating database schema for each feature
08:26
141
First blog post test scenario
05:50
142
Testing protected URLs
07:05
143
Validating returned JSON using patterns (not matching exact values)
06:32
144
Looking for errors and issues using functional tests
03:11
145
Finding a comment problem
06:28
146
Custom error listener
13:06
147
Image upload feature
06:21
148
Working image upload functional test
02:41
149
Testing assigning Images to BlogPost, full suite run
04:50
150
Installing node & npm on Windows
01:19
151
Installing node & npm on MacOS
01:01
152
Installing dependencies and creating main index.js
03:06
153
Creating store, using Provider, Router and components
05:45
154
BlogPostList empty component, App as a container component
02:41
155
BlogPostContainer, using key for list of elements
06:19
156
Redux: actions, reducer, mapping state and dispatch to props 1
07:02
157
Redux: actions, reducer, mapping state and dispatch to props 2
04:36
158
Adding BlogPost (dummy action), Reducer explained
04:29
159
Making API requests with Superagent
05:00
160
Thunk Redux Middleware
09:19
161
Header component (navigation)
03:31
162
Loading indicator when making API requests
03:42
163
Formatting BlogPost list, formatting time (timeago.js)
03:32
164
Route with parameter - individual BlogPost
04:07
165
Fetching BlogPost from API
06:28
166
ComponentWillUnmount lifecycle method
04:42
167
BlogPost component - API changes
02:44
168
Spinner and Message components (loading state, simple message)
05:36
169
CommentListContainer component
10:31
170
CommentList reducer
03:45
171
Rendering comments
02:59
172
Introducing redux-form
02:24
173
Render redux form component
06:28
174
Adding redux-form reducer
02:10
175
Submitting Form to an API endpoint
03:57
176
Storing JWT token in LocalStorage, Token Middleware
03:15
177
Token Middleware and JWT authentication plugin 1
07:11
178
Token Middleware and JWT authentication plugin 2
06:06
179
Reading token in App component constructor
06:30
180
Redux Form submission, handling login errors
03:14
181
Checking whether user is authenticated (in Header component)
03:22
182
Fetching user profile through API
06:20
183
Rendering signed-in username in Header
07:43
184
Fetching user profile on page refresh
05:36
185
Create a redux-form for Comment posting
04:41
186
Redux-form submitting state simulation
02:27
187
Fully working CommentForm
04:21
188
Displaying errors in redux-form
03:43
189
Parsing API errors (validation constraint messages from API)
04:12
190
Animations - animated comment adding
05:47
191
Logout functionality (resetting stored JWT token)
06:20
192
Logging out user when token expires
05:57
193
Logging out user when he submits an expired token (401)
03:03
194
Paginator component
03:47
195
Paginator component - showing current page
02:47
196
Fetching blog post collection on page change
07:10
197
Query parameter based pagination (page in route parameter)
04:34
198
Pagination - previous/next buttons
09:27
199
Modify API - missing User embedded data on new Comment
01:48
200
LoadMore component - fetching next comments (different way of pagination)
08:47
201
Append new comments inside reducer
02:49
202
Registration form
05:32
203
Registration action creators and form validation
10:22
204
ConfirmationToken - modify e-mail to contain token, not only link
03:15
205
RegistrationContainer - 2 step registration process
03:52
206
Showing ConfirmationToken form on successful account creation
05:21
207
Keeping state of registration/confirmation process
05:17
208
Registration/Confirmation process, with redirect timer
08:17
209
BlogPost form for creating posts and user permissions
05:20
210
Functional BlogPost form
05:14
211
ImageUpload component (styling the file input)
06:32
212
Uploading images - upload request
09:50
213
ImageBrowser (preview uploaded images)
05:05
214
A new reducer for BlogPostForm
04:06
215
Clear the images when BlogPostForm unmounts
07:17
216
DELETE operation on Image (API Changes)
04:11
217
ImageBrowser animations
03:38
218
Remove button on ImageBrowser
03:58
219
Remove button on ImageBrowser sending DELETE request
03:16
220
Locking all buttons during Image upload/removal
04:47
Unlock unlimited learning

Get instant access to all 219 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to PHP Symfony 4 API Platform + React.js Full Stack Masterclass?

  • Working with React and Go (Golang) thumbnailUpdated

    Working with React and Go (Golang)

    By: Udemy
    Build a full app pairing a React front end (class components and hooks) with a Go API, including JSON, GraphQL, and JWT authentication.
    24h 48m
  • Redux Saga thumbnailUpdated

    Redux Saga

    By: Pluralsight
    Learn Redux Saga by building a shopping cart app, covering effects, channels, error handling, and testing async flows with confidence.
    2h 54m
  • Build Web Apps with React & Firebase thumbnailUpdated 2y ago

    Build Web Apps with React & Firebase

    By: Udemy
    React is a hugely popular front-end library and React developers are always in hight demand in the web dev job market. In this course you'll learn how to use Re
    23h 34m
  • React End-to-End Testing with Playwright thumbnailUpdated 1mo ago

    React End-to-End Testing with Playwright

    By: Artem Zakharchenko
    The course will help you master end-to-end testing of React with Playwright, set up stable E2E processes, and implement a reliable architecture for automated
    2h 16m

More courses by Udemy

Frequently asked questions

What prior knowledge do I need before taking this course?
While the course is designed to accommodate learners with various levels of PHP experience, having some foundational knowledge of PHP will be beneficial. The course begins with basic concepts such as namespaces, class fields, and methods. It then progresses to more advanced topics like dependency injection and the Reflection API. Familiarity with these concepts will help you understand the material more easily.
What projects will I build during the course?
Throughout the course, you will work on creating a complete API using Symfony 4 and a frontend application with React.js. You will start by setting up a Symfony project, creating entities, and configuring database migrations. You will also learn to implement JWT authentication and build a working admin panel using EasyAdmin. These projects aim to provide practical, hands-on experience in building a full-stack web application.
Who is the target audience for this course?
The course is ideal for web developers who want to enhance their PHP skills by working with Symfony and React.js. Whether you are new to PHP or have some experience but haven't worked with a framework, this course is suitable for you. It is also beneficial for developers aiming to build modern web applications involving APIs and frontend frameworks.
What specific tools or platforms will I learn to use?
You will become proficient in using Symfony 4 for backend development and React.js for frontend applications. The course also covers ORM installation and configuration, API Platform for resource generation, and JWT for authentication. Additionally, you will use tools like Composer for dependency management and Visual Studio Code as your development environment.
What topics are not covered in this course?
The course does not cover advanced React.js practices such as state management with Redux or Context API. It focuses on building the API and connecting it with a React.js frontend, but does not delve deeply into frontend-specific design patterns or extensive UI/UX principles.
How much time should I expect to commit to this course?
The course consists of 220 lessons, each ranging in duration. While the total runtime is not specified, you should expect to dedicate several weeks to complete the material, especially if you are engaging deeply with exercises and projects. Allocating regular, consistent study sessions will help you manage the workload effectively.
How can the skills from this course be applied to other areas or careers?
The skills gained from this course, such as creating APIs with Symfony and building frontend applications with React.js, are highly transferable. They are applicable to a wide range of web development roles, from backend to full-stack development. Understanding JWT authentication and database operations will also be beneficial in various software engineering positions.