Epic Web. Ship Modern Full-Stack Web Applications

39h 2m 51s
English
Paid
December 26, 2023

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.

More

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 Epic Web. Ship Modern Full-Stack Web Applications

Join premium to watch
Go to premium
# Title Duration
1 01. Intro to Full Stack Foundations Workshop 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

Similar courses to Epic Web. Ship Modern Full-Stack Web Applications

Mocking Techniques in Vitest

Mocking Techniques in Vitest

Duration 1 hour 30 minutes 36 seconds
Build Modern Websites with Astro!

Build Modern Websites with Astro!

Duration 7 hours 28 minutes 32 seconds
HTMX - The Practical Guide

HTMX - The Practical Guide

Duration 4 hours 5 minutes
GSAP3: Beyond the Basics

GSAP3: Beyond the Basics

Duration 8 hours 25 minutes 41 seconds
Build & Test Accessible Web Apps | Testing Accessibility (PRO)
Frontend System Design
B-Sides, Bonuses and Oddities

B-Sides, Bonuses and Oddities

Duration 17 hours 55 minutes 38 seconds