Epic Web. Ship Modern Full-Stack Web Applications

39h 2m 51s
English
Paid

Course description

Whether you and your team are working on an existing enterprise-scale web app, or you've just come up with an amazing idea for a new project , the one thing standing between you and your goals is efficiency.

Sure, you can definitely hack your way through the bramble to get to your destination, but at what cost? Time, energy, stress, and (heaven forbid) loss of user trust. 

Nah, let's skip over that. 

You want to get this project to a spot where it's easier to maintain and get your team to a place where you're all on the same page. Start the new project on a solid foundation, or patch up the cracks in the one you've already got.

Epic Web will get you and your team to create that excellent maintainable user experience.

Hey, I'm Kent. As a web developer for over a decade, I've built applications at every scale, enterprise apps, startups with dozens of users, internal tools, and consumer-facing giant tech co. apps with millions of users. I've managed to stay on top of what users have come to expect from applications. You know the feeling you get when an app gives you a modern user experience that just works™️? I know how to get your app there. And that's what this is all about.

I couldn't be more excited to have you join me for this experience. The educational content and open source software I've created has reached more software developers than I can count. I get really jazzed hearing back from developers who apply my ideas to their apps and get jobs, promotions, improved sales, and reduced shipping stress.

Read more about the course

This is not a crash course. It's not "Web Dev 101".

Epic Web is an immersive deep-dive into full-stack development that uses modern technologies to implement first class user experiences at a level of collaborative maintainability and simplicity that you've never seen before.

This workshop series takes you from the frontend to the backend through building the Epic Stack app from scratch. Super practical exercises. Building up to exactly how I build Epic web apps.

You'll go from importing a stylesheet, to uploading files. You'll design a database schema, then interact with it with SQL. You'll build a user authentication system, then test it with automated tests. And so. much. more.

What's included

Full Stack Foundations

7 SECTIONS, 30 EXERCISES

  • Styling: Modern practices for managing CSS.
  • Routing: Plan and implement URL-driven navigation.
  • Loading Data: Strategies for loading and rendering data.
  • Data Mutations: Execute CRUD operations, safely.
  • SEO: Ensure page content gets discovered, organically.
  • Error Handling: Effective strategies, without the ambiguity.

Professional Web Forms

8 SECTIONS, 22 EXERCISES

  • Input Validation: Real-time, schema-based user input validation.
  • Accessibility: Making forms usable for everyone.
  • File Uploads: Support more than just text in your forms.
  • Complex Data Structures: Confidently handle the intricacies of nested data.
  • Form Security: Prevent spam, XSS, and other malicious attacks.

Data Modeling Deep Dive

9 SECTIONS, 22 EXERCISES

  • Database Schema: Craft a robust database architecture with future flexibility.
  • Relationships: Know what and when for one-to-one, one-to-many, many-to-many.
  • Migrations: Seamlessly transition your data.
  • Seeding: Populate initial data for dev and test environments.
  • Query Optimization: Fetch data as efficiently as possible.

Web Authentication

21 SECTIONS, 64 EXERCISES

  • User Preferences: Store settings in the user’s browser.
  • Session Management: Secure data storage done right the first time.
  • Cookie-Based Identification: Identification that follows best practices.
  • Password Storage: Safety beyond just hashing.
  • Password Validation: Security that without inconvenience.
  • Session Expiration: Auto-logout doesn't have to mean data loss.
  • Permissions: Role-based access control.
  • Verification: Verify user emails, support forgot password, 2FA–the works.
  • Third Party Auth: OAuth, multi-connection, SSO-ready.

Full Stack Testing

11 SECTIONS, 28 EXERCISES

  • Test Automation: Ditch manual test suites for scalable automatic ones.
  • HTTP Mocks: Simulate server interactions for E2E tests.
  • Authenticated Tests: Testing with user roles in mind.
  • Unit Tests: Properly scoped and thoroughly executed.
  • React Component Testing: Get into the UI specifics.
  • Integration Testing: Strike a productive balance on test scope.

Each of these workshop modules has been meticulously designed to comprehensively upgrade your skills. We go deep.

There's No Replacement for Fundamentals

There's no denying that new tools like GitHub Copilot and ChatGPT have been an incredible boon to developers, but they're not a replacement for the fundamentals.

You can't just copy-paste your way up the engineering ladder.

When you are responsible for implementing and maintaining web apps, you need to know what you're doing. You need to know how to do it right. Even if you're using third party libraries and services, you need to understand how they work, or you're gonna have a hard time.

Hacking solutions together works in the short term, but it can be costly for your future self.

If you and your team don't build properly, you'll lose time, increase stress, and risk your reputation with your clients and customers.

Your projects should be built to last, by a team that is all on the same page.

A New Kind of Workshop

The Epic Web experience isn't sitting and watching videos.

Each workshop is contained within a specially designed web app that contains all of the exercises, code, and instructions you need to complete the workshop. The app is tightly integrated with your local development environment, so you can code and test your work in real time, in your real world work environment.

If you ever find yourself getting stuck, you have easy access to resources and diffs to help you get back on track. You'll also be invited to join the Epic Web community, where you can ask questions, share your progress, and even find a cohort to work through the workshop with.

After completing a workshop module, you'll be able to download a certificate of completion. Each certificate is served with a mechanism that proves to your team, your manager, or your future employer that you actually did the work. Share it with pride. You earned it.

  • Rising Full-Stack Devs: Get the foundations right.
  • Veteran Coders: Fill in the knowledge gaps you didn't know you had.

Real-World Challenges with Immediate Applications

Whether you're a rising full-stack developer, a veteran coder, or something in-between, Epic Web is the workshop series you've been looking for.

Epic Web's Five workshop modules give you hands-on practice in multiple technologies, and the skills you need to build modern, secure, and scalable web apps:

  • Practical Application: You're not just watching; you're coding for a real app with real requirements.
  • Industry Standard Security: Protect your future apps like a fortress.
  • Database Management: Schema design and optimization; ORM and raw SQL—the real deal.
  • Full Stack Error Management: No more ambiguous "An error occurred" pop-ups.
  • SEO and Accessibility: More than buzzwords; these skills are vital for any app.
  • Confident Shipping: Testing that isn't a complete waste of time.

Dig Deep

You're not here to skim through another workshop; you're here to dig deep.

Epic Web isn't just about learning; it's about applying, about doing. At the end, you won't just have a certificate; you'll have code that does what it's supposed to do, efficiently and securely.

Ready to stop reading and start coding? Let's make web dev magic happen.

Watch Online

This is a demo lesson (10:00 remaining)

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

View Pricing

Watch Online Epic Web. Ship Modern Full-Stack Web Applications

0:00
/
#1: 01. Intro to Full Stack Foundations Workshop

All Course Lessons (478)

#Lesson TitleDurationAccess
1
01. Intro to Full Stack Foundations Workshop Demo
04:00
2
02. Intro to Styling
02:44
3
03. Manage Asset Links in a Remix Application
01:46
4
04. Using Remix's Links Component
03:07
5
05. Asset Import Caching Issue
04:16
6
06. Caching the Favicon
03:55
7
07. Add Custom Fonts to the Global CSS
00:50
8
08. Adding Global Styles to a Remix App
02:35
9
09. Using PostCSS and Tailwind CSS in Remix
01:38
10
10. PostCSS and Tailwind CSS Configuration
05:18
11
11. Bundling CSS in Remix
01:40
12
12. Configure CSS Bundling
06:13
13
13. Dad Joke Break
00:19
14
14. Intro to Routing
08:45
15
15. Routing in Remix
01:40
16
16. Creating User Profile and Notes Pages with Remix Routes
08:24
17
17. Adding Navigation Links
00:51
18
18. Adding Absolute and Relative Links
05:34
19
19. Adding Dynamic Parameter Support
00:56
20
20. Access Params with useParams
03:58
21
21. Adding a Resource Route
02:48
22
22. Example Resource Route Usage
06:41
23
23. Dad Joke Break_2
00:33
24
24. Intro to Loading
03:41
25
25. Loading Data to Your Database
01:37
26
26. Efficient Data Loading in a Remix App
11:31
27
27. Handling Error Messages
01:17
28
28. Handling Error Responses with Remix
05:36
29
29. Dad Joke Break Loading
00:30
30
30. Intro to Mutations
07:43
31
31. Building Forms
00:53
32
32. Creating Form Components with Remix
03:53
33
33. Handling POST Requests for Form Submission
01:04
34
34. Handling Form Submissions and Mutations
06:26
35
35. Handling Form Errors and User Mistakes
01:30
36
36. Form Data Types and Validation
04:26
37
37. Button Forms Data
01:04
38
38. Form Submissions and Mutations
03:34
39
39. Handling Multiple Actions in a Single Action Function
01:01
40
40. Leveraging Name and Value in Buttons for Multiple Form Submissions
04:00
41
41. Dad Joke Break Mutations
00:17
42
42. Intro to Scripting
05:28
43
43. JavaScript in Remix- From Optional to Essential
02:25
44
44. Improving User Experience with Client-Side JavaScript
05:37
45
45. Page Navigation with Scroll Behavior
01:29
46
46. Enhancing Scroll Restoration
02:04
47
47. Environment Variables for Client-Side and Server-Side
07:24
48
48. Exposing Environment Variables in a Web Application
06:45
49
49. Optimizing Resource Loading with JavaScript Prefetching
02:09
50
50. Enhancing User Experience with Prefetching
04:26
51
51. Improve the UX with Pending UI
01:55
52
52. Adding Pending State to Form Submissions with Remix
06:37
53
53. Dad Joke Break Scripting
00:28
54
54. Intro to Search Engine Optimization (SEO)
03:43
55
55. Configuring Meta Tags
00:52
56
56. Meta Tags for Better SEO and UX
02:18
57
57. Dynamic Metadata for Different Routes
00:36
58
58. Managing Meta Tags and Descriptions in RemixRunReact
04:51
59
59. Customizing Meta Tags with Dynamic Data
01:24
60
60. Handling Dynamic Data with Remix's Meta Function
03:02
61
61. Optimizing Metadata for User Info
01:41
62
62. Implementing Dynamic Meta Data for Routes in a TypeScript Application
08:41
63
63. Dad Joke Break - SEO
00:29
64
64. Intro to Error Handling
02:57
65
65. Improving Error Handling and UI on User Profile Page
00:38
66
66. Error Handling and Error Boundaries
05:38
67
67. Handling Expected Errors with Error Boundaries
01:55
68
68. Improving Error Messages for User
02:28
69
69. Streamlining Error Handling in Routes with a General Error Boundary
01:31
70
70. Error Boundaries and Handling in Nested Routes
05:38
71
71. Improving Error Handling with a Document Component
02:11
72
72. Refactoring App Components for Better Error Handling
02:53
73
73. Handling 404 Errors in React Router with Splat Routes
02:01
74
74. Handling 404 Errors with Splat Routes in Remix
04:09
75
75. Dad Joke Break_3
00:32
76
76. Outro to Full Stack Foundations Workshop
01:00
77
01. Intro to Professional Web Forms Workshop
02:11
78
02. Intro to Form Validation
01:32
79
03. Required Field Validation for User Input
00:52
80
04. Form Validation for Accessibility
01:52
81
05. Server-side Validation and Custom Error Messages
01:20
82
06. Server-Side Form Validation and Error Handling
09:42
83
07. Dynamic Error Validation with Hooks
00:49
84
08. Form Validation with Client-Side Hydration
02:44
85
09. Dad Joke Break From Validation
00:21
86
10. Intro to Accessibility
07:56
87
11. Fixing Form Reset Button and Accessibility Issues
01:10
88
12. Improving Accessibility and Form Associations
06:12
89
13. Error Messages and Accessibility with ARIA Attributes
02:02
90
14. Accessible Forms with ARIA Attributes
05:51
91
15. Focus Management for Better User Experience
01:23
92
16. Managing Focus for Form Errors
07:34
93
17. Dad Break Joke Accessibility
00:40
94
18. Intro to Schema Validation
06:44
95
19. Schema Validation
00:30
96
20. Schema Validation with Zod
03:50
97
21. Form Data Parsing with Conform
01:09
98
22. Form Submission and Error Handling with Conform & Zod
03:21
99
23. Type Safety with Conform
00:30
100
24. Simplifying Form Handling with Conform and Schema Validation
08:15
101
25. Dad Joke Break Schema Validation
00:39
102
26. Intro to File Upload
05:09
103
27. File Upload Functionality
01:19
104
28. Image Upload with Form Data and Memory Upload Handling
12:27
105
29. TypeScript Integration
00:37
106
30. Validating File Uploads with Zod Schema in a Web Application
05:43
107
31. Dad Joke Break File Upload
01:00
108
32. Intro to Complex Structures
06:07
109
33. Grouping and Managing Related Fields in Form Objects
00:47
110
34. Implementing Image Field Set with Conform and TypeScript
10:42
111
35. Multiple Image Uploading
01:12
112
36. Dynamic Image Lists with Field Sets
04:57
113
37. Interactive Image Management
02:30
114
38. Dynamically Delete and Add Buttons
10:21
115
39. Dad Joke Break Complex Structures
00:29
116
40. Intro to Honeypot
04:03
117
41. Adding a Honeypot to Protect Against Spam Bots
01:01
118
42. Honeypot Fields in Sign Up Forms
06:14
119
43. Honeypot Fields for Form Security
04:41
120
44. Honeypots for Form Security
00:52
121
45. Honeypot Protection
04:01
122
46. Consistent Encryption with Honeypot Server
01:27
123
47. Setting Up Honeypot Security for Server Environment Variables
03:10
124
48. Dad Joke Break Honeypot
00:33
125
49. Intro to CSRF
05:08
126
50. CSRF Protection with Cookies
01:12
127
51. Creating and Managing CSRF Tokens With Node.js
09:05
128
52. Authenticity With Token Protection
01:06
129
53. Security with Authenticity Token and CSRF Validation
05:21
130
54. Dad Joke Break CSRF
00:14
131
55. Intro to Rate Limit
02:12
132
56. Optimizing Your Express Server with Rate Limiting Middleware
01:14
133
57. Safeguarding Your Server- Adding Rate Limit Configuration
04:33
134
58. Tiered Rate Limiting with Custom Middleware
01:24
135
59. Applying Rate Limiting
04:45
136
60. Dad Joke Break Rate Limit
00:34
137
61. Outro to Professional Web Forms Workshop
00:52
138
01. Intro to Data Modeling Deep Dive Workshop
02:11
139
02. Intro to Database Schema
03:21
140
03. Setting Up the Database with Prisma
00:42
141
04. Database with Prisma and SQLite
09:33
142
05. Dad Joke Break Database Schema
00:32
143
06. Intro to Data Relationships
06:16
144
07. One-to-Many Relationships
01:41
145
08. One-to-Many Relationships in Prisma
06:26
146
09. Database Design
05:50
147
10. One-to-One and One-to-Many Relationships in Prisma
08:17
148
11. Dad Joke Break Data Relationships
00:37
149
12. Intro to Data Migrations
05:22
150
13. Creating Migration Files for Database Management with Prisma
00:40
151
14. Database Migrations with Prisma
05:22
152
15. Dad Joke Break Data Migrations
00:35
153
16. Intro to Seeding Data
03:41
154
17. Configuring Prisma for Seed Script Execution
00:35
155
18. Creating and Managing Data with Prisma Seed Scripts
03:55
156
19. Optimizing Queries with Nested Mutations in Prisma
01:09
157
20. Nested Queries in Database Operations
01:53
158
21. Dad Joke Break Seeding Data
00:58
159
22. Intro to Generating Seed Data
01:53
160
23. Generating Fake Data for Efficient Testing
00:30
161
24. Generating Random User Data with Faker.js for Database Seeding
01:43
162
25. Dynamically Generating Data
02:20
163
26. Generating Dynamic Seed Data
05:51
164
27. Creating Unique User Data with Enforce Unique Library
01:03
165
28. Generating Unique and Valid Usernames in Seed Data
04:59
166
29. Dad Joke Break Generating Seed Data
00:31
167
30. Intro to Querying Data
05:24
168
31. Connecting to a Real Database with Prisma and SQLite
01:01
169
32. Optimizing Prisma Client for Efficient Database Operations
07:29
170
33. Transitioning to Real Database with Prisma API
00:35
171
34. Using Prisma to Retrieve User Data from a SQLite Database
03:29
172
35. Database Queries and Migrating to Prisma
00:30
173
36. Efficient Data Retrieval with Prisma and Subselects
02:46
174
37. Dad Joke Break Querying Data
00:58
175
38. Intro to Updating Data
02:59
176
39. Mutating Data with Prisma
00:39
177
40. Deleting Data with Prisma
00:55
178
41. Updating Page Mutations for Images and Notes with Efficient Cache Control
03:27
179
42. Efficiently Updating and Deleting Data in a Form with Prisma
05:13
180
43. Implementing Transactions for Reliable Data Operations
02:00
181
44. Implementing Transactions with Prisma for Atomic Database Operations
02:50
182
45. Optimizing Database Calls with Nested Queries in Prisma
00:38
183
46. Efficient Database Updates with Prisma's Nested Queries
04:27
184
47. Dad Joke Break Updating Data
00:26
185
48. Intro to SQL
04:31
186
49. SQL Queries for User Search in Prisma
01:22
187
50. User Search with Prisma and SQL
02:48
188
51. Handling TypeScript Errors and Runtime Type Checking with Prisma and Zod
01:28
189
52. Runtime Type Checking and Parsing in Prisma with Raw Queries
06:16
190
53. Working with Joins in SQL
03:10
191
54. Left Joins with Prisma and SQLite
02:24
192
55. Sorting Users by Recent Entry with Raw SQL
01:24
193
56. Leveraging AI Assistance for Writing SQL Queries
03:57
194
57. Dad Joke Break SQL
00:29
195
58. Intro to Query Optimization
12:19
196
59. Optimizing Query Performance with Indexes in Prisma
00:54
197
60. Optimizing Database Queries with Indexes
05:07
198
61. Optimizing User Search Query Performance with Indexing
02:29
199
62. Query Performance with Indexes in SQLite
13:56
200
63. Dad Joke Break Query Optimization
00:47
201
64. Outro to Data Modeling Deep Dive Workshop
00:28
202
01. Intro to Authentication Strategies & Implementation Workshop
04:44
203
02. Intro to Cookies
04:41
204
03. Implementing Theme Switching with Conform and UseFetcher
01:48
205
04. Creating a Theme Switcher with Form Submission and Fetcher in React
03:58
206
05. Adding User Preference for Dark Mode
00:41
207
06. Implementing Cookies for Theme Selection
09:46
208
07. Implementing Optimistic UI for Theme Switching
01:17
209
08. Implementing Optimistic UI with Remix
05:16
210
09. Dad Joke Break Cookies
00:38
211
10. Intro to Session Storage
04:01
212
11. Toast Messages with Cookies
01:46
213
12. Configuring Cookie Session Storage for Toast Messages
04:54
214
13. Adding Toast Notifications to Delete Functionality
00:46
215
14. Managing Toast Messages with Cookie Sessions
04:57
216
15. Improving Note Deletion Functionality with Multiple Cookies
00:39
217
16. Efficiently Updating and Serializing Cookies
04:59
218
17. Implementing Flash Messages for Temporary Notifications
00:47
219
18. Efficiently Removing Toast Messages with Flash API
00:48
220
19. Dad Joke Break Session Storage
00:16
221
20. Intro to User Sessions
00:49
222
21. Managing User Sessions with Separate Cookies
00:23
223
22. Secure Cookie Session Storage
01:15
224
23. User Authentication and Session Management
01:18
225
24. User Authentication and Session Management with Login Forms
06:21
226
25. Load User Avatars
00:21
227
26. Handling User Authentication and Session Management with Prisma
02:38
228
27. Dad Joke Break User Sessions
00:30
229
28. Intro to Password
04:46
230
29. Creating an Optional Password Model in Prisma Schema
00:37
231
30. Model Relationships and Handling Passwords in Database Schema
02:52
232
31. Generating Passwords for Secure User Creation
00:58
233
32. Secure Password Creation with Prisma
03:41
234
33. Enhancing User Creation by Adding Passwords
00:21
235
34. Creating and Hashing Passwords for User Sign-Up
01:47
236
35. Dad Joke Break Password
00:22
237
36. Intro to Login
03:59
238
37. Secure Password Authentication with bcrypt Compare in Node.js
00:18
239
38. Implementing Secure Password Verification in User Login
03:40
240
39. Securing UI Elements
00:45
241
40. Dad Joke Break Login
00:28
242
41. Leveraging Utility Functions for User Data Handling and UI Customization
08:40
243
42. Intro to Logout
01:08
244
43. Transforming a Logout Link into a Secure Logout Form
00:33
245
44. Logout Functionality with Session Storage and CSRF Protection
03:55
246
45. Implementing Remember Me Functionality for Login Sessions
02:59
247
46. Implementing Remember Me Functionality
05:04
248
47. Managing Inactive User Sessions
00:59
249
48. Destroying Sessions and Handling Weird States
01:31
250
49. Implementing Automatic Logout with Modals
03:04
251
50. Auto-Logout Functionality
06:08
252
51. Dad Joke Break Logout
00:42
253
52. Intro to Protecting Routes
01:54
254
53. Creating Protected Routes
00:49
255
54. Creating an Auth Utility
02:54
256
55. Building a Profile Page
01:06
257
56. User Authentication and Authorization
03:57
258
57. Securing User Access
01:22
259
58. Authorization and User Authentication
04:33
260
59. Redirect Functionality
02:05
261
60. Handling Redirects Safely in User Authentication
08:20
262
61. Dad Joke Break Protecting Routes
00:32
263
62. Intro to Permissions
03:38
264
63. Role-Based Access Control with Prisma
00:51
265
64. Modeling Permissions and Roles in Prisma Database
06:36
266
65. Managing Roles and Permissions
01:54
267
66. Seed Data
07:51
268
67. Implementing User Permissions and Authorization Logic
01:34
269
68. Implementing Role-Based Permissions
10:35
270
69. Securing Admin Pages with User Permissions
01:13
271
70. Implementing Role-based Access Control and Permissions
09:44
272
71. Dad Joke Break Permissions
00:39
273
72. Intro to Man Sessions
00:59
274
73. Managing User Sessions and Allowing Data Downloads
00:53
275
74. Integrating User Sessions into the Login Process
01:57
276
75. Implementing Session-Based Authentication
00:49
277
76. Authentication Logic with Session IDs and User Creation
06:44
278
77. Improving Login and Signup Flows with Session Management
00:30
279
78. Updating Login and Signup Routes to Use Sessions instead of User IDs
02:46
280
79. Proactive Session Management
01:18
281
80. Managing Sessions and Sign Out in Web Applications
04:49
282
81. Dad Joke Break Man Sessions
00:30
283
82. Intro to Email
03:33
284
83. Integrating Email Services
01:03
285
84. Sending Emails with the Resend API using Fetch
05:19
286
85. Mocking APIs with MSW and Testing
01:46
287
86. Setting Up a Mock Server with MSW Node
12:12
288
87. Email Verification Flow
01:33
289
88. User Verification Emails
01:05
290
89. Secure Email Transfer and Storage with Cookies for Onboarding
01:52
291
90. Passing Data Between Routes
07:54
292
91. Dad Joke Break Email
00:29
293
92. Intro to Verification
05:12
294
93. Implementing One-Time Password Verification with Database Storage
00:43
295
94. Creating a Verification Model in Prisma for User Verification
04:10
296
95. User Verification Workflow
02:03
297
96. Generating One-Time Passwords and Verification URLs in a Signup Flow
07:47
298
97. Implementing User Code Verification with TOTP
01:07
299
98. Verification Flow and Dynamic Query Parameters
12:20
300
99. Dad Joke Break Verification
00:31
301
100. Intro to Reset Password
01:44
302
101. Implementing Forgot Password and Reset Password Flows
02:32
303
102. Resetting Passwords and Handling Verification
11:06
304
103. User Authentication and Password Reset Flow
00:52
305
104. Secure Password Reset Flow Implementation
05:59
306
105. Dad Joke Break Reset Pass
00:46
307
106. Intro to Change Email
01:33
308
107. Implementing Email Verification for Changing Email Addresses
00:57
309
108. Implementing Email Change Verification
04:33
310
109. Handling Email Verification and Updates
00:26
311
110. Implementing a Secure Email Change Flow
06:17
312
111. Dad Joke Break Change Email
00:23
313
112. Intro to Enable Two-Factor Authentication
02:12
314
113. Implementing Two-Factor Authentication Verification
01:02
315
114. Two-Factor Authentication with TOTP Codes
04:22
316
115. Generating Two-Factor Authentication Codes and QR Codes
01:20
317
116. Generating QR Code and Auth URI for Two-Factor Authentication
05:09
318
117. Testing the Two-Factor Authentication Setup
02:09
319
118. Two-Factor Authentication Code Verification
09:25
320
119. Dad Joke Break Enable Two-Factor Authentication
01:05
321
120. Intro to Verify Two-Factor Authentication (2FA)
01:55
322
121. Two-Factor Authentication and Session Verification
00:37
323
122. Implementing Two-Factor Authentication Flow
06:26
324
123. Switching to Verified Session ID After Code Verification
03:08
325
124. Two-Factor Authentication Login in Node.js
08:31
326
125. Dad Joke Break Verify Two-Factor Authentication (2FA)
00:48
327
126. Intro to Two-Factor Authentication Check
02:49
328
127. Two-Factor Authentication Deletion
00:38
329
128. Disabling Two-Factor Authentication
01:26
330
129. Adding User Re-Verification for Critical Operations
01:52
331
130. Implementing Verification Age Check for Disable 2FA
00:47
332
131. Managing User Verification and Two-Factor Authentication
05:42
333
132. Redirecting Users to Re-verify for 2FA Disabling
04:08
334
133. Session Expiry Issue During 2FA Disablement Flow
02:56
335
134. Fixing Session Expiration Behavior in 2FA Disablement Flow
06:12
336
135. Dad Joke Break Two-Factor Authentication Check
00:32
337
136. Intro to Oauth
08:55
338
137. Integrating GitHub Authentication
01:33
339
138. Setting up OAuth Authentication with GitHub
08:05
340
139. Testing the OAuth Flow with GitHub Authentication
01:18
341
140. Implementing OAuth2 Flow with GitHub for User Authentication
07:39
342
141. Simulating Third-Party Dependencies
06:52
343
142. Simulating GitHub Authentication Flow with Mocks
04:12
344
143. Updating Prisma Schema for GitHub Login
01:25
345
144. Establishing Connections and Seed Script in Prisma for GitHub Authentication
04:43
346
145. Dad Joke Break Oauth
00:36
347
146. Intro to Provider Errors
00:56
348
147. Handling Errors in Third-Party API Calls
00:48
349
148. Handling Errors and Redirecting with GitHub Authentication
01:13
350
149. Handling Connection Errors and Duplication in Account Management
00:46
351
150. Handling Existing Connections in AuthProvider Callback
04:13
352
151. Dad Joke Break Provider Errors
00:35
353
152. Intro to Third Party Login
02:13
354
153. Implementing GitHub Login with Two-Factor Authentication
01:18
355
154. Refactoring Login Logic and Implementing GitHub Login
03:54
356
155. Sign Up with GitHub and Handling Mocked Data
02:28
357
156. Onboarding and User Authentication with Third-Party Providers
11:18
358
157. Dad Joke Break Third Party Login
00:31
359
158. Intro to Connection
01:15
360
159. Connecting Website and GitHub Accounts
01:16
361
160. Automatically Connecting User Profiles with Existing Accounts
04:13
362
161. Adding Multiple GitHub Connections to User Accounts
00:56
363
162. Connecting Existing Accounts with an Auth Provider
01:39
364
163. Dad Joke Break Connection
00:49
365
164. Intro to Redirect Cookie
00:59
366
165. Managing Redirects in Forms and Handling Cookies for Persistent Navigation
00:59
367
166. Adding Redirect Functionality to Login and Signup Forms
01:47
368
167. Handling Redirects and Cookies
01:04
369
168. Handling Authentication Redirects and Cookies
01:58
370
169. Handling Redirects
00:43
371
170. Managing Redirects and Cookies
05:06
372
171. Dad Joke Break Redirect Cookie
00:32
373
172. Outro to Authentication Strategies & Implementation Workshop
00:58
374
01. Intro to Web Application Testing Workshop
01:32
375
02. Intro to End-to-End
06:23
376
03. Writing Automated Tests with Playwright UI Mode
02:38
377
04. Writing and Asserting Playwright Tests for Search Functionality
10:17
378
05. Isolating Tests for Better Reliability and Flexibility
01:02
379
06. Creating and Interacting with User Data
02:02
380
07. Test Isolation in End-to-End Testing
02:01
381
08. Proper Setup and Teardown of Testing for Database Cleanup
01:02
382
09. Implementing Fixtures to Ensure User Deletion in Playwright Tests
02:06
383
10. Playwright Fixtures for Testing
06:29
384
11. Dad Joke Break E2E
00:27
385
12. Intro to E2E Mocking
05:14
386
13. Writing Emails to the File System for Test Automation
01:33
387
14. Handling Emails in Node.js using File System
02:31
388
15. Reading Email from Disk in Test Environment
00:22
389
16. Communicating Between Processes with File System in Node.js
03:19
390
17. Dad Joke Break E2E Mocking
00:36
391
18. Intro to Auth E2E
03:23
392
19. End-to-End User Flow Testing and Authentication Utility
02:06
393
20. Login and Setting Cookies for Browser Testing
07:26
394
21. Dad Joke Break Auth E2E
00:59
395
22. Intro to Unit Test
03:12
396
23. Unit Testing a Function for Error Messages
00:43
397
24. Writing Unit Tests for Utility Functions
06:56
398
25. Managing Test Output and Error Logging with Console Mocking
02:12
399
26. Testing Console Error with Spies
04:19
400
27. Implementing Test Hooks for Error Restoration in Playwright
01:00
401
28. Effective Error Handling and Console Capture Testing
05:16
402
29. Creating a Setup File for Test Environment Setup
00:44
403
30. Setting Up Test Environment and Utilizing Setup Files with VTest
03:45
404
31. Dad Joke Break Unit Test
00:58
405
32. Intro to Component Testing
05:50
406
33. Error List Component with React Testing Library
00:32
407
34. Testing React Components with JSDOM
05:58
408
35. Proper DOM Cleanup for Reliable Testing
00:19
409
36. Ensuring Isolation and Proper Test Execution
04:50
410
37. Dad Joke Break Component Test
00:13
411
38. Intro to Hooks
07:03
412
39. Double Confirmation Feature
04:04
413
40. Testing Custom React Hooks with RenderHook and Act
09:25
414
41. Custom Test Components vs Render Hook Utility
01:13
415
42. Testing React Hooks
05:59
416
43. Dad Joke Break Hooks
00:26
417
44. Intro to Testing Remix
03:38
418
45. Creating a Stub for Testing Component Logic in Remix
01:29
419
46. Rendering Components with Mock Data
07:14
420
47. Creating a Parent Route for Accessing Root Data
01:11
421
48. Creating Routes and Context in Remix
03:38
422
49. Dad Joke Break Testing Remix
00:27
423
50. Intro to Http Mocking
02:24
424
51. GitHub Sign-In Callback
02:05
425
52. Testing OAuth2 Flow and Mocking GitHub API Responses
10:10
426
53. Testing Error Handling in GitHub API Interceptor
01:29
427
54. Testing Error Handling and Assertions with Mock API Calls
05:54
428
55. Streamlining Repetitive Test Setup for Optimal Efficiency
01:03
429
56. Efficient Code Organization with Setup Functions
02:36
430
57. Dad Joke Break Http Mocking
00:54
431
58. Intro to Auth Integration
03:08
432
59. Testing Authenticated Requests and Connection Creation
01:03
433
60. Creating and Authenticating Users for Connection Setup
08:45
434
61. Assertions for GitHub Login Session Creation
00:35
435
62. Verifying Session Creation and User Authentication
02:56
436
63. Integrating Real Database with User Routes
00:40
437
64. Authentication in Database Integration Tests
07:32
438
65. Dad Joke Break Auth Integration
01:02
439
66. Intro to Custom Assertions
03:03
440
67. Custom Matchers for Assertions
01:38
441
68. Custom Assertions with Jest's Expect Library
04:22
442
69. Dad Joke Break Custom Assertions
00:46
443
70. Intro to Test Database
04:04
444
71. Setting Up a Test Database for Prisma Integration Tests
02:15
445
72. Setting Up an Isolated Database for Tests
06:25
446
73. Optimizing Database Seeding for Faster Execution
00:46
447
74. Optimizing Database Seeding for Faster Execution_2
01:32
448
75. Managing Test Databases for Parallel Testing
01:04
449
76. Isolating Test Databases for Efficient Testing
01:11
450
77. Optimizing Test Setup
01:26
451
78. Optimizing Test Setup with Global Database Configuration
05:55
452
79. Dad Joke Break Test Database
00:28
453
80. Outro to Web Application Testing Workshop
00:39
454
001 Content Management Systems with Alexandra Spalato
29:58
455
002 Leadership in Tech with Ankita Kulkarni
29:14
456
003 API Mocking with Artem Zakharchenko
38:37
457
004 Enhancing SQLite with Ben Johnson
44:46
458
005 The Evolution of Type Safety with Colin McDonnell
39:59
459
006 Simplifying Web Form Management with Edmund Hung
39:06
460
007 Scalable Databases and Authentication with Iheanyi Ekechukwu
27:34
461
008 Understanding Web Development with Jacob Paris
27:45
462
009 The Depth of Software Testing with Jessica Sachs
35:50
463
010 Platform Engineering with Jocelyn Harper
38:08
464
011 Navigating the Testing Terrain with Debbie O'Brien
25:34
465
012 Exploring the Front-End Ecosystem with Mark Dalgleish
37:45
466
013 Navigating Changing Web Technologies with Mark Thompson
45:43
467
014 The Magic of TypeScript with Matt Pocock
48:39
468
015 Building Deep Skills with Michael Chan
42:11
469
016 Examining MDX with Monica Powell
31:29
470
017 Efficient Form Management with Sandrina Pereira
30:11
471
018 Transitioning from Rails to Remix with Sergio Xalambri
39:18
472
019 The Capabilities and Ecosystem of Tailwind CSS with Simon Vrachliotis
41:18
473
020 The Crucial Role of Database Optimization with Tyler Benfield
54:52
474
021 Product Management with Nevi Shah
36:02
475
022 From Tech Sales to Engineering with Shaundai Person
36:00
476
023 Remix Behind the Scenes with Ryan Florence
46:07
477
024 Art, Code, and Data Visualization with Shirley Wu
43:09
478
025 The Future of Authentication with Will Johnson
33:24

Unlock unlimited learning

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

Learn more about subscription

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

SolidJS: The Complete Guide

SolidJS: The Complete Guide

Sources: Sinan Polat
This book is the result of two years of meticulous work. SolidJS may seem simple at first glance, but its internal structure includes complex...
Web Components Demystified

Web Components Demystified

Sources: Scott Jehl
If you are like me, then you have probably been hearing a lot about web components lately. Many of us are looking for ways to integrate web components into...
7 hours 51 minutes 36 seconds
Full-Stack Fundamentals 2 - Backend

Full-Stack Fundamentals 2 - Backend

Sources: Mckay Wrigley (takeoff)
In the first project, we focused on the frontend, creating a personal portfolio website. Now we will take the next step towards full-stack development...
1 hour 45 minutes 49 seconds