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