AUTHOR

Louis Sanna

Join us as we dive into the world of AI-powered streaming text and chat UIs using TypeScript, React, and Python. 

Large Language Models (LLMs) are revolutionizing various industries, but creating simple demos in notebooks or with tools like Gradio is not enough. To truly harness the potential of these models, we need to build sophisticated, real-world applications.

This comprehensive course is structured into six detailed modules where you will:
- Develop a dynamic front-end with React.
- Integrate FastAPI with LangChain to create a robust backend.
- Utilize Server-Sent Events (SSE) for seamless real-time data streaming.

This comprehensive course comes packed with valuable extras:
- The complete source code under MIT licence
- Exclusive access to our community forum
- Detailed exploration of Retrieval-Augmented Generation (RAG) for enhancing model responses
- Hands-on experience with developing intelligent agents capable of maintaining context in conversations

Taught by [Louis Sanna](https://www.linkedin.com/in/louis-sanna-0168363a/), a seasoned Tech Lead with expertise in GenAI applications and digital transformation projects for major organizations like UNESCO and Renault. His deep industry insights and practical experience will guide you from basics to advanced implementations.

Taking this course will spare you countless days of troubleshooting and challenges, offering a shortcut through the learning curve. Moreover, it presents a unique opportunity to engage with one of the most significant technological trends of our era. This is your chance to become a part of the groundbreaking wave of LLM advancements, positioning you at the forefront of innovation.

### Problem this Course Solves

This course is designed to tackle specific problems that AI engineers face when integrating LLM capabilities into web applications. Streaming text presents a unique challenge for engineers, requiring the integration of multiple technologies and concepts. This course addresses this by:

- Exploring the use of Langchain for seamless LLM provider switching. Given Langchain's rapid development, understanding its streaming, asynchronous, and callback functionalities can be daunting.
- Demystifying asynchronous programming in Python, which can be more complex than in JavaScript. We'll cover the differences between asynchronous and synchronous programming, the benefits of asynchronous operations, and how to implement and integrate asynchronous function calls within a streaming context.
- Selecting and implementing a protocol for streaming text from the backend to the frontend. We will explain why Server-Sent Events (SSE) is an ideal standard, despite being relatively new and unfamiliar to many.
- Creating an SSE endpoint using a Python server framework, such as FastAPI, to facilitate real-time data streaming.
- Reading the stream in the front-end using the ReadableStream interface of the Fetch API, ensuring efficient data handling.
- Updating the React state of prompts with consideration for React's batching behavior to prevent unexpected issues during rapid updates.
- Integrating custom components within text responses to enable dynamic, on-the-fly generative UIs.

By the end of this course, you will have a comprehensive understanding of how to effectively integrate and manage LLM capabilities within web applications, overcoming the technical hurdles associated with real-time text streaming.

### Preview the Application

Experience the power of what you'll build firsthand. Try out the demo app we will develop during the course:
[The Demo App](https://build-ai-driven-web-applications.vercel.app/)

Enroll now and start building transformative AI-powered applications that streamline communication and enhance user engagement!

### Course Content Overview

##  Basic Package
- Total Modules: **6**
- Total Lessons: **20**
- Total Video Runtime: **1 hour, 10 minutes**

##  Advanced Package
- Total Modules: **7**
- Total Lessons: **24**
- Total Lines of Code: **3706**
- Total Video Runtime: **1 hour, 34 minutes**

Dive into Retrieval Augmented Generation and Autonomous Agents with LangChain, Chroma and FastAPI

Large Language Models are reshaping industries, yet integrating them into real-time streaming UIs presents unique challenges. In this course we will learn how to seamlessly integrate LLM APIs into applications and build AI-powered streaming text and chat UIs with TypeScript, React, and Python. Step-by-step, we will build a full-stack AI application with quality code and very flexible implementation.

The LLM application in this course includes:
- Completion Use-Case (english to emojis)
- Chat
- Retrieval Augmented Generation use-case
- AI Agent Use-Cases (code execution, data-Analyste agent)

This app can be used as a starting point in most projects, saving a huge amount of time, and its flexibilty allows new tools to be added as needed.

At the end of this course, you will have mastered end-to-end implementation of a flexible and high-quality LLM application. This course will also equip you with the knowledge and skills necessary to create sophisticated LLM solutions of your own.

Responsive LLM Applications with Server-Sent Events

How to design systems for AI applications

How to stream the answer of a Large Language Model

Differences between Server-Sent Events and WebSockets

How asynchronous programming in Python works

What problems Retrieval Augmented Generation can solve

Alyssa Holland

**The Approachable Guide to Accessible Components** is designed to provide a comprehensive understanding of web accessibility. The course covers foundational principles, practical techniques, and hands-on projects to solidify the concepts. From learning the basics of ARIA and assistive technologies to building and testing accessible components, you will gain the skills necessary to create inclusive web applications. Each module builds upon the previous one, ensuring a cohesive and thorough learning experience.

### Course Content Overview
Course Overview:
Total Modules: **8**
Total Lessons: **22**
Total Video Runtime: **2 hours, 20 minutes**

### Why Accessibility Feels Daunting
Accessibility is a broad and massive topic that includes a myriad of nuances and subtopics. 

For many developers, understanding and implementing accessibility is a challenge that often feels different from any other aspect of web development.  This challenge is compounded by the fact that accessibility guidelines can seem abstract and difficult to apply in practical scenarios, leading to frustration and uncertainty.

The thing is that accessibility isn't just about writing code. It's about having empathy and understanding the needs of diverse users to ensure that your applications are usable by everyone, regardless of their abilities. 

### How this Course Helps
The course demystifies the complex world of web accessibility with the following process: 
- **Building a Solid Foundation**: Establish a deep understanding of **core accessibility principles** that serve as the groundwork for your learning, ensuring that the concepts you grasp early on will **naturally integrate and reinforce** the more advanced techniques you'll apply later on in the course.
- **Practical Projects**: Through hands-on projects, you'll **apply what you learn** in real-world scenarios, making abstract concepts **concrete and understandable**.
- **Comprehensive Skill Set**: Learn a **diverse range of techniques**, from established principles to modern practices like headless components, expanding your toolkit for creating more accessible user interfaces.

This course is designed to familiarize you with accessibility standards and ensure you can apply these principles in real-world scenarios effectively. By blending foundational knowledge with practical application, you'll leave this course equipped and confident in your ability to create components that are both functional and inclusive.

Learn WAI-ARIA Standards and Craft Accessible Components for a More Inclusive UX

Explore fundamental accessibility concepts and apply your knowledge by building real-world UI components. 
This course provides a solid foundation that you can build upon with relevant examples that help make the concepts "stick". Learn the ethos behind ***why*** accessibility is important, ***what*** the techniques are to create accessible components, 
and ***how*** to apply those principles when building out sample components. By the end of this course, you will have built a “lens” for accessibility, created practical components that meet accessibility standards, and obtained the skills to identify and address accessibility issues.

The Approachable Guide to Accessible Components

ARIA and its role in assistive technology.

Using proper labels and inputs to craft accessible forms.

Testing for accessibility using tools like screen readers and browser extensions.

Definitions of common accessibility terminology and acronyms.

Ensuring color contrast and visual affordances for interactive elements.

How to manage focus and keyboard interactions.

How to leverage modern UI patterns like headless components to build accessible components.

Chris Frewin

In **Master Custom React Hooks with TypeScript**, you will learn everything you need to start — completely from scratch — to publishing a fully-fledged React Hook built with Typescript, including a variety of complex features, detailed documentation, and a fully interactive example site. The course spans **4 modules** with a total of **19 lessons** and **over 2 hours of video content**. Here's a preview of what you'll learn in each module:

After completing Craft a Custom React Hook npm Package with React and TypeScript, students now possess the skills to build amazing React Hooks with React and TypeScript.

What the Students are Saying

react

typescript

Building Title Looping Functionality with the useEffect Hook

Implementing a Cascading Letter Functionality

Organize and abstract away complexity with React Hooks.

19 Video Lessons on React and TypeScript

Interactive, Live Project Demos

Complete Project Source Code

### Master the Art of Building Advanced React Hooks with TypeScript

Welcome to "Master Custom React Hooks with TypeScript," a comprehensive online course designed to elevate your skills in React development, more preciesly in creating Custom React Hooks with TypeScript. Led by seasoned software engineer Chris Frewin, this course dives into the intricacies of building custom and open-source React Hooks using TypeScript.

### Why React Hooks are Such a Pain to Learn

Learning React Hooks can be a formidable journey, especially for seasoned engineers venturing into new territories. Add TypeScript to the mix and the challenge becomes even greater. Here are common challenges you may have encountered:

- The official React documentation is infamous for its lack of complex examples, and it's even harder to find production-ready examples using both React and TypeScript combined. 
- The intricacies of React Hooks and TypeScript may seem daunting, leading to a sense of overwhelm as you navigate through the complexities of these technologies.
- Integrating TypeScript seamlessly with React and understanding how to leverage it effectively can be a puzzle, causing frustration for those aiming to build robust applications.
- Mastering state management with React Hooks requires a deep understanding of React fundamentals. Many face challenges in effectively utilizing useState, useEffect, and other hooks for optimal application performance. One of these most famous pitfalls is the infinite re-render loop that can occur when using useEffect.

### How This Course Helps

This course addresses these frustrations head-on, providing you with practical lessons filled with code implementations based on real-world experience to navigate the complexities of React Hooks and TypeScript with confidence.

### Why Invest Your Time in React Hooks and TypeScript Now?

In the dynamic landscape of software development, staying current is crucial. Here's why learning React Hooks and TypeScript is not just beneficial but essential for software engineers like yourself:

1. **React with React Hooks and TypeScript reigns as the Gold Standard of Web Development:** Even today, React is still oen of the most popular JavaScript frontend framework. By mastering React Hooks and TypeScript, you position yourself at the forefront of modern web development, ensuring your skill set aligns with the latest industry standards.

2. **Enhanced Developer Productivity:** TypeScript's static typing and React's declarative approach can significantly boost your productivity, allowing you to catch errors early and streamline your development workflow.

3. **Industry Demand:** Employers increasingly seek developers well-versed in React Hooks and TypeScript. Adding these skills to your arsenal makes you a sought-after professional in today's competitive job market.

4. **Optimized Application Performance:** React Hooks provide a more efficient and scalable way to manage state and side effects, contributing to the creation of high-performance applications that meet user expectations.

5. **Community Support and Resources:** The React and TypeScript communities are thriving. Learning these technologies now means tapping into a vast pool of resources, support forums, and collaborative opportunities.

Investing your time in mastering React Hooks and TypeScript not only equips you with cutting-edge skills but also positions you for success in the ever-evolving field of software development allowing you to join the ranks of forward-thinking developers embracing these technologies.

### Course Content Overview
Course Overview: Total Modules: **4** Total Lessons: **19** Total Video Runtime: **2 hours, 19 minutes**

Build Powerful React Hooks with TypeScript

Learn how to build an advanced React Hook with TypeScript, you will start from a blank editor and end with a complete and published open-source npm package.
This course contains 19 lessons, each complete with live coding examples for students to study and build upon. 
By the end of the course, you'll have built an extremely clean React Hook and published it to npm with multiple features, documentation, and a fully interactive example site. Along the way, you'll also learn best practices around using TypeScript with React Hooks.

Master Custom React Hooks with TypeScript

Build a powerful hook that enables complex functionality with just one line in a component of your choice.

Build a React Hook npm package with built-in TypeScript type declarations.

Build an example site that updates the hook's properties in real-time.

How to craft **custom React Hooks using TypeScript**

Importance of the **full lifecycle** (mount, unmount, and more) of React Hooks

How to **integrate TypeScript types** with custom React Hooks

What problems **TypeScript with React Hooks** can solve

How to create a **community-ready** custom React Hook package that is a **joy to use**

How to add basic functionalities including **Title Looping**, **Packaging the Module** using **Roolup**, and **Cleaning Up and Refactoring** just to name a few.

How to add advanced functionalities including the immplementation of **Cascading Letter**, **Marquee**, **Favicon Modification**, **Interval Time as a Hook Parameter**, and **Should Always Plas as Hook Parameter** just to name a few.

 How to implement optimization such as **Custom Types**, **Development-only Warning Logger**, preventing concurent usages of the Hook, restoring origional values on **Refocus** and **Unmount**, and more.

Malith

Embark on a transformative learning journey with our course, **Real-Time Collaborative Apps with Next.js and Supabase**. Gain comprehensive insights into every facet of constructing a real-time application using Next.js. Throughout the course, you will actively engage in creating a fully functional real-time feature, providing you with invaluable hands-on experience. Elevate your skill set and empower yourself to master the intricacies of building dynamic applications in the ever-evolving landscape of web development.

### How The Course Works:

- **Online**: The "Real-Time Collaborative Apps with Next.js and Supabase" course is a comprehensive online program spanning six modules.
- **Remote Access**: Take advantage of the course from any location, allowing you the flexibility to engage with the materials at your convenience.
- **Self-Paced Learning**: Tailor your learning experience to your schedule, enabling you to progress through the course content at your own pace.
- **Community Engagement**: Collaborate and learn alongside a diverse community of fellow students, fostering an environment of shared knowledge and support.
- **Structured Learning**: Experience a well-organized curriculum designed to provide a cohesive and comprehensive understanding of Angular Signals in a logical progression.

### Understanding the Challenges

1. **Synchronization Complexity:**
 Ensuring that all users see the same real-time updates simultaneously can be complex. Managing data synchronization across different clients and dealing with potential conflicts requires careful planning.

2. **Latency Issues:**
 Latency is a constant challenge in real-time applications. Achieving low-latency communication between clients and the server is crucial to maintaining a seamless user experience.

3. **Scalability:**
 As the number of users increases, scalability becomes a significant concern. Ensuring that the system can handle a growing user base while maintaining real-time responsiveness is a challenge that needs careful consideration.

4. **Conflict Resolution:**
 In collaborative environments, conflicts can arise when multiple users attempt to edit the same piece of data simultaneously. Implementing effective conflict resolution strategies is essential to maintain data integrity.

5. **Security:**
 Real-time collaborative features often involve sharing sensitive information. Ensuring the security of the communication channels and protecting data from unauthorized access is paramount.

6. **Cross-Browser Compatibility:**
 Different browsers may have varying levels of support for real-time technologies. Ensuring cross-browser compatibility is crucial to providing a consistent experience for all users.

7. **Testing and Debugging:**
 Real-time features can be challenging to test thoroughly, especially when dealing with various network conditions and client environments. Debugging issues related to real-time updates requires specialized tools and careful monitoring.

8. **User Experience:**
 Maintaining a smooth and intuitive user experience can be challenging, especially when dealing with frequent updates. Striking a balance between providing real-time information and avoiding overwhelming users with constant changes is crucial.

9. **Infrastructure Considerations:**
 Setting up and maintaining the infrastructure to support real-time communication, including WebSocket connections or other technologies, requires careful planning and consideration of server resources.

10. **Compatibility with Existing Systems:**
  Integrating real-time features into an existing application may pose challenges in terms of compatibility with the current architecture and technologies in use.

Addressing these challenges requires a combination of solid architectural design, thoughtful implementation, and continuous testing and optimization throughout the development process.


### Advantages of Learning to Build Real-Time Collaborative Features with Next.js and Supabase in 2024

1. **High Demand for Real-Time Applications:**
 The demand for real-time applications continues to rise across various industries, including communication, collaboration, and entertainment. Learning to build real-time features positions you well for opportunities in these domains.

2. **Enhanced User Experience:**
 Real-time features provide users with a more engaging and interactive experience. Learning to implement these features allows you to create applications that feel dynamic and responsive, contributing to a positive user experience.

3. **Versatility Across Industries:**
 Real-time collaboration is not limited to a specific industry. The skills you acquire can be applied in sectors such as healthcare, education, finance, and more, making you versatile in your development capabilities.

4. **Competitive Edge in the Job Market:**
 As real-time features become increasingly integral to modern applications, having the skills to implement them can give you a competitive edge in the job market. Employers value developers who can create applications with real-time capabilities.

5. **Supabase's Ease of Use:**
 Supabase provides a user-friendly platform for building real-time applications, offering features like real-time database updates out of the box. Learning Supabase can streamline the development process and enable you to build powerful applications more efficiently.

6. **Community Support and Documentation:**
 The Next.js and Supabase communities are active and supportive. Learning within these ecosystems means having access to a wealth of resources, tutorials, and community forums where you can seek help and share knowledge.

7. **Scalability and Performance:**
 Modern real-time technologies, when implemented correctly, can handle large-scale applications with ease. Learning to build scalable and performant real-time features ensures that your applications can grow to meet increasing demands.

8. **Integration with Other Technologies:**
 Real-time features often complement other technologies such as serverless architecture, APIs, and cloud services. Learning how to integrate real-time capabilities into a broader tech stack enhances your ability to create robust and interconnected applications.

9. **Stay Current with Industry Trends:**
 Staying up-to-date with the latest technologies and industry trends is crucial for a successful career in software development. Real-time collaboration is likely to remain a key focus, and learning these skills keeps you relevant in a rapidly evolving tech landscape.

10. **Entrepreneurial Opportunities:**
  Knowing how to build real-time collaborative features opens up opportunities for creating your own innovative applications or services. Whether you're working for a company or venturing into entrepreneurship, these skills empower you to bring dynamic solutions to the market.

Always consider checking the latest updates and trends in the industry to ensure that the technologies you're learning remain relevant.


### Course Content Overview

Course Overview:
Total Modules: **6**
Total Lessons: **18**
Total Video Runtime: **1 hour, 9 minutes**

### Summary:
This course is here to assist you in efficiently creating real-time applications using Next.js, TypeScript, Tailwind CSS, Supabase, and Progress. We go beyond the fundamentals, guiding you through the complexities of real-time techniques and highlighting the importance of selecting the appropriate technology for each project or feature.

Bring Real-Time Capabilities to Modern Next.js Applications

This course is here to assist you in efficiently creating real-time applications using Next.js, TypeScript, Tailwind CSS, and Supabase. We go beyond the fundamentals, guiding you through the complexities of real-time techniques and highlighting the importance of selecting the appropriate technology for each project or feature.

Real-Time Collaborative Apps with Next.js and Supabase

Importance of Learning Real-Time Features

Setting Up The Next.js Project with Supabase

How to Integrate Supabase Real-Time with Next.js

Exploring Server-Sent Events (SSE) Under The Hood

Giorgio Boa

Enter your name and email address below, then click the **"Send my free chapter"** button to get started

250+ page PDF

EPub

newline Access with Replits

All Code Samples

Discord Community Access

One-time price of $69

( the primaryDescriptionMarkdown is long - several lines, include images, as long as you want )

In this course we <headline of what we do>. <why this technology is good> but <here's how learning it is problem>. 

In <the length of these lessons> we cover <three salient points about what we cover. Your BEST points>. Its <however long it is> and comes with <these bonus features, and reasons to buy. code, etc.>

It's taught by <author name> who <credibility, reason you should listen to them>. <social proof, if you have it yet>

<then you can list other supporting stuff you want to add, anything you want here>

-------
Example:
-------

We created a free course to create your first GraphQL server (from scratch) using Node and TypeScript. TypeScript and GraphQL are a powerful combo, but there's a lot of confusing edges if you're getting it setup the first time.

In this course we cover the basics of getting TypeScript setup with Node, how GraphQL works, and how to set up a GraphQL server using Apollo server. It's two hours long, it comes with complete code examples, and we walk through the code step-by-step.

It's taught by my friend, Shopify-engineer Hassan Djirdeh and he's integrated what he's learned using GraphQL in production as an engineer at Shopify. We've already had over 1,300 students enroll and it's been getting great reviews so far.

// ... and so on

Harness Qwik Resumable Architecture for Lightning-Fast Startup Times

In this course we <headline of what we do>. <why this technology is good> but <here's how learning it is problem>. 

( the summary is short - one or two lines )

Complete Guide to Qwik

Katharina

A resume that you created on a **Vue.js Resume Builder**, a Vue.js Resume Builder that **YOU** created! Now **THAT’s** the good stuff. That’s that stuff that distinguishes **YOU** from the flock of **“Word” and “PDF”**.

### 5 Reason for Creating your Resume Builder in Vue

1. Vue.js is very **performant**: It works with a virtual DOM, a lightweight representation of the actual DOM. It allows Vue to optimize updates and significantly improves performance.

2. With its component-based development, Vue helps **structure code**, which makes maintaining it easier.

3. Vue.js simplifies the **rendering of content** immensely: When your data changes, the connected part of the DOM automatically re-renders.

4. Vue is a **progressive framework**: That means you can introduce Vue into an existing project. You don't have to rewrite everything, instead, you can only use Vue for a specific page or section of your project.

5. It is **open-source**, and you can be sure that it will be continued due to its popularity.

### Overcoming Challenges in Vue and Developing a Resume Builder

If you are already familar with CSS, HTML, and JavaScript, with the gentlest learning curve, Vue is your doorway into a fully-fledged front-end or even a full-stack web developer.

Mastering Vue can present a learning curve for absolute beginners unfamiliar with CSS, HTML, and JavaSrcript, this is due to its extensive features and concepts like data properties, methods, computed properties, custom events, and lifecycle hooks. While Vue offers excellent [documentation](https://vuejs.org/guide/introduction.html), it can be challenging for developers to get a deeper understanding without a structured learning path.

The best way to familarize yourself with a new framework is to work on a portfolio project, and this course is exactly that. You won't find anything about creating a portfolio project in any offical documentation. This course also provides a **structured learning path**, breaking down complex concepts into manageable lessons.

Our aim is to ensure that you progressively build your understanding of Vue, starting from the basics and advancing to more complex topics. And thus, this course is tailored for Vue.js beginners, leveraging the Options API in Vue 3 for its **beginner-friendly** approach.

We emphasize practical application as the most effective way to become familiar with the material, ensuring you apply newly introduced concepts from the course's very first lesson. Instead of practicing on simple to-do list apps, you have the opportunity to create a substantial portfolio project that you can showcase to friends, potential employers, and even use for yourself to create a Developer Resume.

### Course Content Overview
Course Overview:
Total Modules: **5**
Total Lessons: **14**
Total Video Runtime: **1 hour, 30 minutes**

Enhance your Portfolio with a Kickass Vue 3 Resume Builder

“**Word” or “PDF” resume pfft!** You’re better than that and you know it. In this course, you will create a **customizable developer resume from scratch in Vue.js** with features and tools to make meaningful changes in the content and the design of your developer resume.

This course will also teach you all the fundamental concepts of Vue, with code-along video lessons, detailed explanations, and hands-on exercises. By the end of the course, you'll have a deep **understanding of Vue**, a **stylish developer resume**, and a **portfolio project** that demonstrates your Vue knowledge.

Interactive Vue.js Resume Builder

Creating a highly configurable and customizable Resume Bilder in Vue

Setting up Vue projects with the Single File Components architecture

Component reactivity and dynamic data rendering with Vue directives

Computed properties and component methods

Communication between components via props and custom events

Conditional styling through class and inline style bindings

300+ page PDF

Become a confident JavaScript pro by unraveling the most challenging aspects of the language. With easy-to-understand explanations and code examples, you’ll gain a deeper and solid understanding of JavaScript's most complex features.

Advanced JavaScript Unleashed is for beginner and intermediate developers alike, who want to elevate their JavaScript skills and become senior engineers by gaining a deeper understanding of the core topics of the language.

Advanced JavaScript Unleashed

Travis Waith-Mair

Learn the Best Practices and Design Patterns behind every CSS layout. Know exactly what you *should* and *shouldn't* do at all times. And develop the intuition to **break every layout into its simplest building blocks** and the ability to **recreate it with both CSS Grid and Flexbox**.

### Why CSS Feels Hard and Frustrating

CSS is different than any other programming language. That's because it's not a programming language itself.

And that's why **CSS can feel painful, stressing, and overwhelming**. 

A common misconception is that with enough practice and experience, it will somehow just "click" eventually, but it doesn't work that way. 

This is what happens when you try to build a layout without first learning, understanding, and implementing the fundamentals. 

And this is when **CSS feels like throwing mud at the wall and hoping something sticks**. 

This is when editing a layout feels like defusing a bomb where one wrong move will turn everything to dust.

Flexbox and Grid definitely make things easier, and so does Bootstrap and TailwindCSS. **But these alone are not enough to help you feel confident in your abilities to build complex, responsive CSS layouts**.

It's like thinking you're a great painter because you have a canvas and a brush.

**These are just *tools***. But to paint a masterpiece, you need to know the fundamentals of painting.

And to build a picture-perfect layout that will last, **you *need* to learn the fundamental CSS Design Patterns**.



### How *Mastering CSS Layouts* Helps:

*Mastering CSS Layouts* teaches you the 7 fundamental Design Patterns that are used to build every layout in existence in the most simple and sturdy way that's easy to make responsive. 

You'll not only be able to recognize them, but also know *exactly* **how to use them in real-life scenarios like complex landing pages, SaaS interfaces, and more**.

You can finally **feel confident in your ability to build any layout there is from scratch** or edit an existing layout without breaking anything. 

Because you'll **know what you should and shouldn't do when building your layout**. 

Thanks to the best practices and foundational building blocks that are used to build all complex and responsive layouts.

These Design Patterns work with both Flexbox and CSS Grid so **you can use whichever you want** whenever it's time to build or edit a layout. 

And when you see a layout that seems harder to implement, you'll know **how to stack patterns on top of each other to achieve the exact result you want** every single time.  

### Course Content Overview

Course Overview:
Total Modules: **5**
Total Lessons: **24**
Total Video Runtime: **1 hour, 27 minutes**

Unlock the Secrets of CSS Layouts with Practical Expertise in Design Patterns

Become confident in building any CSS layout by learning the fundamental CSS Design Patterns and Best Practices that are responsible for all the CSS layouts in the world. 


Make CSS easy and intuitive by identifying those building blocks in seconds in every layout and learn how to code each of them using CSS Grid or Flexbox. By the end of this course, CSS will finally "click". 


Everything will make sense and you'll know how to build from scratch or edit  both simple and complex layouts.

Mastering CSS Layout

Build a responsive landing page using modern CSS layout patterns.

Implement modern CSS layout patterns with CSS Flexbox and Grid.

Optimally accommodate different grid layouts for cards with CSS Grid.

Drop cards to their own columns upon screen size changes with CSS Flexbox.

**How to make CSS make sense** by understanding the fundamental building blocks of web pages

How to **build *any* layout you want** and keep it sturdy and unbreakable

How to **instantly recognize common problems** in web layouts

What are **the 7 Design Patterns that help you solve every layout problem** you're going to ever face

How to **detect what design patterns were used and where** in each layout

How to implement these Design Patterns **in both CSS Grid *and* Flexbox**

**What you should and shouldn't do** when building your layouts

**When to use CSS Grid** and when to opt for Flexbox instead (and why)

How to **become confident in your CSS layout skills**

Akinwale Folorunsho Habibullah

**Pain Free Mocking with Jest** teaches you how to effectively and painlessly test JavaScript applications with Jest. You'll start by learning how to write unit and integration tests as well as the 'How', 'What', and 'When' of Mocks, Stubs, and Spies. Then we'll move to more advanced technique and strategies you'll be using for the rest of your career, including how to have a hollistic approach to testing and how to automatically add your tests in the development lifecycle.

### The Issue With Unit Testing & Mocks

Writing unit tests has always been equal parts important and confusing. 

While writing your first unit test is simple and easy, the learning curve becomes very steep very quickly once you have to test actual real-life scenarios. 

Because suddenly, you have to know how to **mock a database call** or **spy an HTTP request** or **stub a 3rd party API with a security token**. When you have to test real-life scenarios like that, things become much more complex than they initially seemed.

With every test case being different from the next one, and with Mocks not being used anywhere else in coding except for testing, it's hard to find quality information online. Every answer is different from the next one and is aimed for an ultra-specific scenario that won't necessarily apply to any other case, including yours. 

Instead of making things clear, this confuses things even further. 

### How "Pain Free Mocking with Jest" Helps:

"Pain Free Mocking with Jest" is designed to make testing painless by helping you understand once and for all the 'How', 'What', and 'When' of Mocks, Spies, and Stubs using the Jest testing framework.

You will learn how to write simple and complex test cases, utilize Jest's mocking capabilities, and gain hands-on experience with real-world testing scenarios that involve Databases, HTTP requests, and 3rd Party APIs. 

By the end of the course, you'll feel confident using Mocks, Spies and Stubs in any scenario you may need them. You'll have all the knowledge and tools you need to create complete test suites and confidently test JavaScript applications *with* mocking *without* headaches.

### Course Content Overview

Course Overview:
Total Modules: **6**
Total Lessons: **37**
Total Video Runtime: **2 hours, 28 minutes**

### Summary:
- Build and test a Node.js REST API application with authentication features like 'Sign Up' and 'Sign In'. 
- Learn how to test everything from simple functions all the way to Controllers that interract with 3rd party web services.
- Learn the 'What', 'How', and 'When' of Mocks, Spies, and Stubs.
- Learn to see your application code in testable units. 
- Write integration tests for HTTP endpoints, controllers, middleware functions, and 3rd party integrations.
- Create Git hooks to run unit tests before each commit 
- Build a CI pipeline using Github Actions to automate running integration tests on each git push to Github.

Learn to confidently test JavaScript applications and mock dependencies using Jest, the pain-free way. 

Understand how to painlessly use Mocks, Spies, and Stubs to test any part of your application, without worrying about Databases, APIs and Security Tokens. 

After finishing this course (which only takes a single afternoon), you'll feel confident in your testing skills because you'll have all the knowledge and tools you need to effectively and painlessly test even complex applications in the real world without headaches.

Pain Free Mocking with Jest

How to write unit and integration tests with Jest

How to test functions that interact with Controllers, APIs, and Databases (without relying on their responses)

How to test code in isolation with Mocks, Spies, and Stubs using Mockingoose

How to write integration tests for HTTP endpoints and database connections

Advanced mocking and integration testing techniques like the 3A pattern, network manipulation, and more

How to become a test strategist with the Agile Testing Quadrant, create CI test pipelines, and add tests to the development lifecycle

deji adesoga

### How The Course Works:

- The "Build a Modern Web Application using Angular Signals" course is a comprehensive online program spanning five modules. Discover how to effectively utilize Signals to manage the entire state of an Angular application, integrate the newly built-in control flows, employ deferrable views, navigate components using lazy loaded routes, and implement Standalone components.
- Remote Access: Take advantage of the course from any location, allowing you the flexibility to engage with the materials at your convenience.
- Self-Paced Learning: Tailor your learning experience to your schedule, enabling you to progress through the course content at your own pace.
- Community Engagement: Collaborate and learn alongside a diverse community of fellow students, fostering an environment of shared knowledge and support.
- Structured Learning: Experience a well-organized curriculum designed to provide a cohesive and comprehensive understanding of Angular Signals in a logical progression.

### Understanding the Challenges

Learning Angular 17 can present various hurdles and frustrations for those new to the technology. As individuals navigate their journey into this advanced framework, they commonly encounter several challenges:

- Complexity Barrier: The intricate architecture and extensive feature set of Angular 17 can overwhelm newcomers, posing a significant learning curve.
- State Management Complexity: Managing the state of an Angular application efficiently, especially with the nuances of Signals, can prove challenging for learners.
- Integration Puzzles: Integrating and harnessing newly built-in control flows, deferrable views, Standalone components, and lazy loaded routes can be intricate and perplexing.
- Navigational Complexity: Understanding the intricacies of lazy loaded routes and effective navigation between components can pose obstacles to a smooth learning experience.

Navigating through these complexities without guidance can hinder the progress of aspiring developers aiming to master Angular 17.


### Advantages of Learning Angular 17 in 2023

- Enhanced Performance: In 2023, Angular 17 offers optimized performance enhancements, enabling you to craft high-performing web applications capable of meeting modern user expectations.
- Cutting-Edge Features: Stay ahead in the web development landscape by mastering the latest built-in control flows, deferrable views, and other advanced functionalities unique to Angular 17.
- Industry Relevance: With Angular continuing to be a sought-after framework in the industry, mastering Angular 17 ensures you remain competitive and relevant in the job market.
- Improved Developer Experience: Angular 17 introduces refinements and enhancements that streamline the development process, providing a more efficient and enjoyable experience for developers.
- Scalability and Maintainability: Learning Angular 17 equips you with the knowledge to build scalable and maintainable applications, crucial factors in modern software development.

### Why Learn Angular 17 in 2023

Angular 17 stands at the forefront of web development frameworks in the current year, offering you several compelling reasons to dive into its intricacies:
Embrace the evolution of web development by mastering Angular 17 in 2023. This advanced version presents you with enhanced performance capabilities, cutting-edge features, and improved developer experiences. Remaining proficient in Angular ensures your relevance in a competitive industry, equipping you with the skills necessary to build scalable, high-performing applications that meet the demands of modern users.

### Course Content Overview

Course Overview:
Total Modules: **5**
Total Lessons: **12**
Total Video Runtime: **1 hour, 41 minutes**

### Summary:
This course is structured into five comprehensive modules, guiding you through the intricacies of Angular 17 Signals. From laying the groundwork with introductory concepts to diving deep into handling HTTP requests, sharing data between components, and culminating with a thorough review in the conclusion module, each section builds upon the last, empowering you to master Angular 17 Signals effectively.

Learn how to surgically manage state and optimize UI rendering with Angular Signals. This course introduces students to the world of Angular Signals, from reactive primitives to seamless interoperability between observables and signals. By the end of this course, you'll have learned how to build a highly performant, lightweight Angular application that features deferrable views, lazy loaded routes, and a PayPal-powered checkout flow. Additionally, you'll have learned the techniques needed to modernize older Angular applications so that they're able to fully leverage the power of Angular Signals.

Demystifying Reactivity with Angular Signals

Fetch data from a REST API making use of Signals.

Make use signals to add functionalities to the shopping cart

Checkout selected items from the cart using the available Signal APIs

How to manage state in an Angular application by making use of Signals

The importance of using Signals to enhance change detection

How to integrate a robust lazy loading approach, by making use of deferrable views and lazy loaded routes

Difference between using RxJS and Signals when working with data and asynchronous operations

How to structure an Angular application using Standalone components

How to work with the newly built-in control flows

Fernando Doglio

NextJS

# Complex State Management in Next.js 13+ with Server and Client Components
_Sharing and managing state between server and client components is not trivial_, especially with the limited 
information available online. This course will take you through all the basics you need to answer the question:

> How do I share state between server and client components in Next.js?

## Module 1: Intro & Getting Started
_Begin your journey by understanding the essentials of Next.js 13+ and state management._

- **Overview**: Get an introduction to the core principles and concepts of Next.js 13+. Familiarize yourself with the course structure, the instructor's background, and the tools you'll be using.
- **Goals**: Set clear expectations about what the course will cover, including fundamental problems related to state sharing between server and client components.

## Module 2: State
_Understanding the heart of React applications: state._

- **General Concept of State**: Dive into what state really means in the context of web applications. Explore how state affects the design and functionality of your app.
- **Local vs Global State**: Master the differences and applications of both local and global state to make informed decisions in your coding practice.
- **Management Techniques**: Get to grips with various strategies and tools for managing application state, including popular third-party libraries.

## Module 3: Client Components
_Dissect Client Components and unravel their role within Next.js._

- **Component Structure**: Break down the anatomy of client components, learning how to create them and understanding their role within the application.
- **Capabilities and Limitations**: Examine what client components can do, understanding their scope and limits, and what is reserved for server components.
- **Proper Utilization**: Develop a keen sense for the appropriate use of client components, paying special attention to interactivity and dynamism. Wrap up with a quiz to reaffirm your knowledge on client components.

## Module 4: Server Components
_Unveil the capabilities and edge of using Server Components in Next.js._

- **Understanding Server Components**: Define what server components entail and their architecture, emphasizing state-related functions and limitations.
- **Contrasting with SSR**: Compare server components to traditional server-side rendering and understand when and why server components offer an advantage.
- **Best Practices**: Learn to discern when it's most appropriate to use server components, and explore the "server-land" where certain server-side actions take place. A checkpoint with a pop quiz will round up the module, cementing your understanding of server components.

## Module 5: Page Architecture
_Review and refine the structures that make up your Next.js applications._

- **Maximizing Performance and Simplicity**: Explore the design patterns that allow you to make the most of Next.js features, leading to optimized performance and simplicity in your project structure.
- **Practical Application**: This module revisits the concept of page architecture, providing more complex and practical examples of how to partition components for scalability and maintainability.

## Module 6: Sharing State between Client and Server Components
_Integrating the dual realms of Next.js, bringing together server and client component state management._

- **Identifying the Problem**: Delve into the nuances of managing and sharing state in server components, identifying when it differs from client-side state management.
- **Cross-Component Communication**: Learn how to efficiently pass state and props between server and client components.
- **Working with Cookies and HTTP Requests**: Gain hands-on experience with cookies as a mechanism for shared state, and leveraging HTTP requests to sync state across the server-client divide.

_By the end of this course, participants will acquire a comprehensive understanding of managing state within Next.js 13+ applications, effectively using both the server and client components to build robust, scalable, and maintainable web applications._

Learn the Best Practice and Architectural Patterns Behind React Server Components and Client Side Components

Learn how server components work in Next.js and how you can use them to share state between 
the client and server. 
Learn the best way to architect pages by combining server and client components and improve the overall performance and UX of your apps.

Next.js Complex State Management Patterns with RSC

How to combine server and client components to improve page loading times

How to use props to share state from server to client components

How to take advantage of hydrated state to share state between client and server components

Eric Burel

The **Blazing Fast Next.js with React Server Components** course equips you with the skills needed to master Next.js Static Rendering, coupled with Server Actions but also client-side and dynamic rendering. From foundational concepts to practical implementation, you'll gain a deep understanding of how to leverage Next.js for optimal performance and dynamic content delivery.

## **Blazing Fast Next.js with React Server Components**

### Build a Content Application with Dynamic Data - Newline Commerce

Welcome to the "Blazing Fast Next.js with React Server Components - Design patterns to accelerate Next.js Apps with Static Rendering and Server Actions" course. Throughout this program, we will guide you through the intricacies of Next.js, focusing on Server Actions and static rendering techniques. In this informative journey, we will collaboratively construct a content application named Newline Commerce.

Join us as we explore the foundations of Next.js, implementing dynamic data and server-side actions to bring Newline Commerce to life. This course is your gateway to mastering the art of server actions and static rendering in the context of real-world web development.

### How The Course Works

- The Blazing Fast Next.js with React Server Components course is a 6-module online program where you will delve into Next.js powerful patterns such as Server Actions, Static Rendering, Client-Server Relaying or Partial Prerendering. Learn to deliver fresh content to your end users with optimal performances and cost efficiency.
- Remote: Take the course from anywhere, allowing you to participate from the comfort of your preferred location.
- Self-paced: Tailor the course to fit your schedule. With a self-paced structure, you have the flexibility to learn at your own pace, ensuring a stress-free educational experience.
- Community: Engage with other students in a collaborative learning environment. Share insights, discuss challenges, and expand your understanding within a supportive community.
- Structured: Experience a cohesive and organized learning journey. The course is structured to guide you through each module in a logical and progressive fashion, ensuring a comprehensive understanding of Next.js Server Actions and Static Rendering.

### The Challenge

Navigating the realm of Next.js can be a daunting endeavor for many aspiring developers. As you embark on your journey to master this powerful framework, you may encounter several challenges:

- **Complexity Overload:** Next.js, with its robust capabilities, can overwhelm newcomers. Understanding the intricate balance between Next.js server-centric features and data update requirements requires a structured approach.
- **Dynamic Content Dilemma:** Implementing dynamic content in web applications often poses a challenge, especially when it comes to delivering fresh data efficiently to end users.
- **Performance Concerns:** Ensuring optimal performance while maintaining cost efficiency is difficult. Achieving this balance with Next.js demands a nuanced understanding of its patterns and practices.
- **Lack of Cohesive Learning Resources:** Piecing together information from various sources can be time-consuming and confusing. A structured learning path is essential for a comprehensive understanding of Next.js.

### The Frustration

Newcomers often find themselves frustrated by the lack of clarity and guidance in mastering Next.js. The complexity of static rendering aside from trivial use cases can be a significant roadblock, leading to confusion and hindered progress.

### How This Course Helps

The "Blazing Fast Next.js with React Server Components" course is designed to address these challenges head-on. Through a carefully crafted curriculum, you will gain a clear understanding of Next.js, overcome common hurdles, and confidently apply static rendering with revalidation in your web development projects.


### Unlock the Potential of Next.js in 2024

In the dynamic landscape of web development, staying ahead is key. Here's why learning Next.js in 2024 is advantageous for you:

1. **Enhanced Performance:**
Next.js continues to evolve, offering enhanced performance features that cater to the growing demand for faster, more efficient web applications.
2. **Industry Relevance:**
As of 2024, Next.js maintains its position as a leading framework, backed by a vibrant community and widespread adoption in the industry. Learning it now ensures you align with current development trends.
3. **Scalability for Modern Applications:**
In an era where scalability is paramount, Next.js provides the tools to build scalable applications that adapt to the demands of modern web development.
4. **SEO Optimization:**
Next.js server-side rendering capabilities contribute to improved SEO performance, a crucial factor for ensuring your web applications are discoverable and accessible.
5. **Developer-Friendly Ecosystem:**
With an ever-expanding ecosystem and a focus on developer experience, learning Next.js in 2024 means immersing yourself in a framework designed to streamline your development workflow.

Equip yourself with the skills to thrive in the current web development landscape. Learning Next.js in 2024 positions you at the forefront of technology, offering a competitive edge in your professional journey.

Design patterns to accelerate Next.js Apps with Static Rendering and Server Actions

Learn how to build blazingly fast websites with Next.js. Static rendering is often underrated: it’s very fast, very cheap, but hard to use in advanced scenarios. This course introduces students to personalization with static rendering by using React Server Components, the latest paradigm shift in React. By the end of this course, you'll have learned advanced Next.js concepts like server actions, static revalidation, client-server relaying, or partial prerendering, and you'll know when and how to apply different server rendering strategies in large, production-grade Next.js applications. This course mixes recent advanced concepts like Server Action and static rendering in a way that students won’t find in the documentation. Not only will this apply to any content application but also it will apply to dashboards or multi-tenant SaaS.

Blazing Fast Next.js with React Server Components

Why the performance of a content application matters and how it's related to different rendering strategies

How to statically fetch data on a server with React Server Components (RSC)

How to update static pages with fresh content via data revalidation in Server Actions

How to perform relaying with SWR, a React Hooks library for data fetching

How to mix dynamic and static rendering via Partial Prerendering (PPR), an experimental feature introduced in Next.js 14

Connor Rothschild

In the [Better Data Visualizations with Svelte](/courses/better-data-visualizations-with-svelte) course, not only will
you learn to enhance beeswarm plots with filters and peripheral elements, but you will also learn how to:

- **Build a Scatterplot with a Tooltip**
- **Build a Rotating Globe Visualization**
- **Build an Interactive Scrollytelling Scatterplot**

If you enjoyed the free course, then check out the [Better Data Visualizations with Svelte](/courses/better-data-visualizations-with-svelte) course below!

svelte

In this free, one hour course, we will learn how to create a dynamic, physics-based beeswarm plot with Svelte and D3. Beeswarm plots offer an elegant and dynamic way to display distributions, outliers, and patterns within our datasets. Whether you're a seasoned developer or a curious beginner, this course will guide you step-by-step through the process of creating a stunning and interactive beeswarm plot that will captivate your audience.

We will start by scaffolding a new Svelte project. Then, we will cover the fundamentals of `d3-force` and the underlying force simulation that arranges nodes, which are represented as circles, in a physics-based, D3 force layout. This approach will automatically position nodes in clusters via a chosen categorical variable and prevent node collisions/overlap. Svelte will handle the rendering of these nodes to the DOM.  

As we progress through the course, we will come across common problems that developers encounter when integrating Svelte with D3's `d3-force` module, and we will learn how to address them using Svelte's reactivity system. Finally, we will dynamically color and size the nodes in the beeswarm plot based on specific dimensions of our dataset.

This course aims to be an introductory guide to creating a dynamic, physics-based beeswarm plot with Svelte and D3 from scratch. By the end of the course, you will know how to bring your beeswarm plots to life with Svelte's declarative syntax and D3's data manipulation and mathematical capabilities.

Learn how to create a dynamic, physics-based beeswarm plot with Svelte and D3. This free course contains three lessons that cover everything from the basics of d3-force for positioning circles in a beeswarm plot (via a force layout) to dynamically styling and sizing circles in a beeswarm plot. By the end of the course, you will have built a simple beeswarm plot that visually summarizes a distribution of data.

Building a Beeswarm Chart with Svelte and D3

Build a dynamic, physics-based beeswarm plot with Svelte and D3.

Explore the basics of D3 force simulations.

Perform updates via Svelte reactive blocks.

How to create a dynamic, physics-based beeswarm plot for the web

The importance of enforcing clear separation of concerns (Svelte for the DOM, D3 for mathematical calculations)

How to integrate Svelte and D3 to create interactive beeswarm plots

Differences between the imperative (pure D3) and declaractive (Svelte and D3) approaches to building modern data visualizations

What problems using Svelte in D3 data visualizations can solve

How to create a beeswarm plots that allow you to better understand the extent and distribution of your data

Kristian Dupont

This comprehensive course will equip you with the skills and knowledge to build modern full-stack applications using TypeScript, TailwindCSS, tRPC, and PostgreSQL. You will learn how to create a robust and scalable application architecture, from the backend data layer to the frontend UI.

PostgreSQL

NodeJS

Knex

React

TypeScript

tRPC

Tailwind CSS

Monorepos simplify code development and can be split when necessary.

Working With Monorepos

Setting up npm workspaces in our monorepo

Workspaces

Setting up shared Typescript, ESLint and Prettier configs

Shared Configs

Vitest

Shared Components for Styling your React Application

Shared Components

Master full-stack development with a single repository for everything!

In this comprehensive course you will gain the skills and knowledge to build modern full-stack applications using TypeScript, TailwindCSS, tRPC, and PostgreSQL.

You will learn how to create a robust and scalable full-stack application architecture using PostgreSQL, NodeJS, Koa, Knex, React, TypeScript, tRPC, and Tailwind CSS, that is enforced with type safety, from the backend and data layer to the frontend UI.

### How The Course Works

- **Online**: The "Real-Time Collaborative Apps with Next.js and Supabase" course is a comprehensive online program spanning six modules.
- **Remote Access**: Take advantage of the course from any location, allowing you the flexibility to engage with the materials at your convenience.
- **Self-Paced Learning**: Tailor your learning experience to your schedule, enabling you to progress through the course content at your own pace.

**Community Engagement**: Collaborate and learn alongside a diverse community of fellow students, fostering an environment of shared knowledge and support.

**Structured Learning**: Experience a well-organized curriculum designed to provide a cohesive and comprehensive understanding of Angular Signals in a logical progression.

### Embrace the Full TypeScript Stack for Next-Level Web Development

"Move fast and break nothing" is the slogan on the tRPC landing page. Having type safety across your entire stack, from the database schema to the frontend UI, is a game changer. The course focuses on creating a type-safe application with the database as the source of truth.

The components used in this course are all mature and well-supported. The components are all open-ended, meaning these components aren't something that gets you going quickly but then becomes a burden when you need to do something they don't support. The architecture you will learn will be able to scale, not only in terms of complexity and performance requirements, but also in terms of the number of developers working on it.

Through hands-on examples and real-world scenarios, you'll learn how to integrate a suite of technologies to create a seamless development experience. 

By the end of this course, you will end up with a solid structure and understanding of how to solve the various challenges that come with building a full-stack application.

### Understanding the Challenges

This course aims to address several challenges in web app development, particularly as the codebase expands. Some of the challenges that this course focuses on include:

- **Minimizing errors**: The course emphasizes type safety, which helps ensure that variables and expressions align with their designated types, reducing the likelihood of errors.
- **Setting up a deployable app**: The course focuses on providing a foundation of infrastructure that is easy to build on, aiming to clear out most of the capital expenditures (CAPEX) involved in setting up an app for deployment.
- **Database as the source of truth**: The course guides you in using the database as the foundational source of truth for your application, allowing for advanced features and retaining type safety.
- **Simplifying the development process**: By using a monolithic architecture and avoiding unnecessary microservices, the course aims to simplify the development process and avoid premature complexity.
- **Providing a starting point for various SaaS applications**: While the course focuses on building a booking system, the architectural concepts and foundations covered can be applied to various SaaS applications.


### Why This Course?

- **Focus on Type Safety**: Learn the importance of type safety in reducing errors and building reliable software.
- **Database as Source of Truth**: Utilize advanced features of PostgreSQL to manage your application's data effectively.
- **Modern Technologies**: Get up to speed with current best practices using technologies like React, tRPC, and Tailwind CSS.
- **Scalability and Maintenance**: Prepare your applications for growth with scalable architecture and maintainable code.
- **Testing**: You will see how to set up testing of all parts of the stack, using a real database and type safety to ensure your application works as expected.

### Course Content Overview
Course Overview: Total Modules: **8** Total Lessons: **30** Total Video Runtime: **4 hours, 30 minutes**

### Summary
This comprehensive course will equip you with the skills and knowledge to build modern full-stack applications using TypeScript, TailwindCSS, tRPC, and PostgreSQL. You will learn how to create a robust and scalable application architecture, from the backend data layer to the frontend UI.

Build type-safe full-stack applications with database-centric strategies

Create a robust and scalable application architecture, from the backend data layer to the frontend UI. This comprehensive full-stack development course covers monorepos, TypeScript, Tailwind CSS, tRPC, and PostgreSQL, empowering you to build modern, scalable applications. Learn how to build a SaaS with type safety end-to-end, from the database through the backend and to the UI, with TypeScript, PostgreSQL, NodeJS and React. Using advanced features of PostgreSQL, you'll also learn how to achieve a high level of data integrity and performance, and how to manage database migrations using raw SQL for maximum control.

Fullstack Typescript with TailwindCSS and tRPC Using Modern Features of PostgreSQL

Master monorepos for streamlined development workflows and enhanced collaboration

Implementing type safety across your entire stack, starting from the database schema

Utilize Tailwind CSS to create consistent and beautiful user interfaces

Employ tRPC for seamless data exchange between frontend and backend

Managing database migrations using raw SQL for maximum control

Integrating modern back-end and front-end technologies

Harness advanced PostgreSQL features for optimized data storage, retrieval, and manipulation

Setting up automated testing that utilizes type safety and a real database

Build modern, scalable full-stack applications using a unified approach

Costa Alexoglou

In this course, we will dive into the world of design systems. We will learn how they can help developers increase their productivity, create consistency across a company's products, and ultimately speed up the development process.

We will start by covering the fundamental concepts of design systems, then move on to the architecture of a monorepo codebase. We will set up shared configurations for TypeScript, ESLint, and Prettier, and create a foundation package for hosting and distributing design tokens and assets.

Next, we will create a React package with demo components that are styled using our design system's style tokens. We will also create a Storybook package and learn the best practices for developing and documenting components with TypeScript. We will focus on styling our components in two ways: using CSS-in-JS with styled-components and JavaScript design tokens, as well as Tailwind CSS classes.

Finally, we will learn how to create tests for our React components using React Testing Library and AXE, and manage releases using changesets and set up a CI pipeline with GitHub Actions.

This course aims to be a comprehensive guide, or a cookbook, to building a complete company design system from scratch. By the end of the course, you will have the knowledge and skills to create a practical and maintainable design system for any organization.

This course is a comprehensive guide to publishing your first component library and design assets using React, TypeScript, Storybook, Tailwind CSS, and Styled Dictionary. You’ll create a flexible, enterprise-grade design system library that your co-workers will actually enjoy.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Explore newline courses

Masterclasses

Tutorials

Fullstack React with TypeScript