Backend with Node

Section 1: Introduction to Backend and Node.js

1. Prerequisites
2. What Is Backend & Client Server Architecture?
3. CLI vs GUI
4. What Is Node.js and What Is It Used For?
5. Installing Node.js
6. Running Our First Node.js Code
7. Why Do We Need Node.js and How Is It Different From JavaScript in Browser?
8. A Brief History of Node.js

Section 2: Basics of Terminal

1. Introduction to Terminal and Shell
2. Basic Shell Commands (echo, pwd, whoami)
3. Navigating the File System (cd)
4. Listing Directory Contents (ls)
5. Creating, Copying, Moving, and Deleting Files and Directories (touch, mkdir, cp, mv, rm, rmdir)
6. Viewing and Editing Files with Commands (cat, nano, vim)
7. What Is Prompt in Terminal?
8. Configuring Our Terminal Using .bashrc File
9. Using Aliases for Command Shortcuts (alias)

Section 3: Basics of OS

1. What Is CPU, Processor, and Core?
2. What Is OS and Kernel?
3. What Is a Process?
4. What Is Thread, Concurrency, and Parallelism?
5. Can a Process Exist Without a Thread?
6. Debugging Worker Threads
7. What Is an Environment Variable?
8. Setting and Using Environment Variables
9. Installing Windows Subsystem for Linux (WSL)
10. Understanding the Path System: Windows vs. Linux Explained
11. What are Executable Files?
12. Managing File Permissions
13. How Commands Get Executed?
14. Important Methods and Properties of The Process Object

Section 4: Fundamentals of Node.js

1. Module System in Node.js
2. Introduction to Common JS Module System
3. module.exports VS exports
4. module Object
5. Module Wrapper Function
6. Custom Require Function
7. ES6 Modules
8. Accessing filename and dirname in ES6 Modules
9. Why Different Module Systems?
10. Difference Between Common.js and ES6 Modules
11. Different Types of Modules
12. NPM and NPM Modules
13. Creating and Publishing NPM Modules
14. Understanding package.json File in Depth
15. What is Shebang?
16. Library VS CLI Packages and Local VS Global Packages
17. How npx Works?
18. What is npx?
19. Introduction to FS Module
20. Word Counter CLI Project
21. Writing to a File Using Node.js
22. Node.js File Operations: Rename, Delete, Move, Copy & More

Section 5: Data Representation in Computing

1. Introduction to Data Representation in Computing
2. Decimal Number System
3. Octal Number System
4. Hexadecimal Number System
5. Binary Number System
6. Introducing Programmer's Calculator
7. Digital Data Uints
8. Binary Data on Physical Level
9. Why DO We Use Decimal System?
10. Character Sets vs Character Encodings (ASCII and Unicode)
11. Understanding UTF-8 in Depth
12. What are Unicode Planes?
13. UTF-8 vs UTF-16 vs UTF-32
14. Byte Order Mark (BOM) and Endianness (Big Endian & Little Endian)

Section 6: Mastering Buffers - Handling Binary Data in Node.js

1. Introduction to Buffers
2. ArrayBuffer in JavaScript
3. Signed and Unsigned Values
4. Reading and Writing to Array Buffers
5. Writing Multi-Byte Data
6. Typed Arrays
7. Transferring Array Buffer Data from Memory to Disk and Network
8. Buffer in Node.js
9. Alloc VS AllocUnsafe
10. Buffer Pool in Node.js
11. Buffer Methods and Properties
12. Practical Use of Buffers
13. Limitations of Buffers
14. Base-64 Encoding
15. Base-64 in Node.js

Section 7: Event-Driven Architecture and EventEmitter in Node.js

1. What is an I/O Operation?
2. What is Async I/O?
3. Introduction to Event-Driven Architecture
4. The EventEmitter Class
5. Creating and Emitting Events
6. EventEmitter Methods

Section 8: Node.js Streams - Handling Data Flow like a Pro

1. Introduction to Streams
2. Types Of Streams in Node.js
3. Readable Streams
4. Different States of Readable Streams
5. Internal Buffer of Readable Streams
6. More about Readable Streams
7. Writable Streams
8. Backpressure and Internal Buffer of Writable Streams
9. Closing Writable Streams
10. States of Writable Streams
11. Piping Streams
12. Piping Using Pipeline
13. Duplex, Transform and Passthrough Streams
14. Data Streams
15. Piping and Redirection of Data Streams
16. Writing 1 Lakh Numbers
17. Why Streams Are So Fast?
18. What is a File Descriptor?
19. Reading File with File Descriptor
20. Opening Files in Different Modes
21. Writing to a File with File Descriptor
22. Write One Lakh Numbers Faster than Streams
23. Implementing Internal Buffer in our Custom Stream
24. Handling Files Using Promises
25. Working with Streams using Promises
26. How Browsers use Streams?
27. Streams in JavaScript

Section 9: Basics of Computer Networking

1. Why Should We Learn Networking?
2. What is Computer Networking?
3. Story of The Internet
4. Story of DNS
5. Story of World Wide Web
6. Important Networking Devices
7. Types of Network
8. Creating Our Own LAN
9. Creating Our Own WAN
10. How Internet Comes to Our Homes?
11. How does Mobile Internet Work?
12. Understanding IPv4 Addresses in Depth
13. Dynamic vs Static IP Address
14. Private vs Public IP Address
15. Benefits and Drawbacks of Public and Private IP Addresses
16. How to get Public IP Adresss?
17. Turning Our Laptop into a Public Server
18. Running Multiples Severs on our Laptop
19. Understanding Domain Name System (DNS)
20. Connecting Our IP Address with a Domain Name
21. How DNS Servers Work?
22. DNS Hijacking
23. Understanding IPv6 Addresses
24. Turning Our Mobile Phone into a Public Server
25. What are Port Numbers?
26. Inspecting Port Numbers with Wireshark
27. What are Network Interfaces?
28. What is MAC Address?
29. What is Firewall?
30. Understanding OSI Model
31. Understanding TCP/IP Model
32. Network Topologies
33. TCP and UDP: The Backbone of the Internet
34. Remote Terminal Access Using SSH
35. Transferring files using SCP
36. SSH Public and Private Keys
37. Connecting to Multiple SSH Servers
38. Creating AWS Account
39. Understanding AWS EC2 Instance
40. AWS Cost Management
41. More Topics to Learn

Section 10: Networking with Core Node.js Modules

1. Networking Capabilities of Node.js
2. Creating UDP Server in Node.js
3. What is Socket?
4. Transferring Files Using UDP
5. Creating TCP Server in Node.js
6. Creating TCP Client using Node.js
7. Handling Multiple TCP Clients
8. Transferring Files Using TCP
9. Creating HTTP Server using Net Module
10. Understanding HTTP Headers
11. Important Response Headers
12. Controlling Data Transfer Speeds
13. Inspecting TCP Data Packets in Wireshark
14. Why We Await Twice When Making a Fetch Call?
15. Uploading Files
16. Creating HTTP Server Using HTTP Module
17. HTTP Request Methods
18. HTTP Response Status Codes
19. Creating HTTP Client
20. Anatomy of HTTP Request and Response
21. Creating a Web Server
22. Creating Online Storage Platform Like Google Drive
23. Implementing Preview and Download Feature in Our Storage App
24. Client-Side vs Server-Side Rendering
25. Separating Our Client-Side and Server-Side Code
26. Implementing File Upload with Progress
27. Adding Delete Functionality
28. Implementing Rename Functionality
29. Making Our App Live on Internet

Section 11: Building RESTful CRUD APIs with Express.js

1. Intro to Express.js
2. How Express Works Behind the Scenes?
3. What is Middleware in Express?
4. Handling Different HTTP Methods in Express
5. Difference Between Route and Request URL
6. Adding Global Middleware with app.use() Method
7. Adding Route-Specific Middleware
8. Serving Static Files using Express
9. Sending JSON using Express
10. Making File Storage App in Express
11. Dynamic Routing in Express
12. Handling File Uploads in Express
13. What is CORS?
14. Understanding Preflight Request
15. Adding Single-Level Nested Directory Support in Our Storage App
16. Adding Multi-Level Nested Directory Support
17. Adding Directory Creation Functionality
18. Understanding Path Traversal Vulnerability
19. Fixing Vulnerability with Path Module
20. Organizing Routes using Express Router
21. Understanding the Problem with Our Code
22. Creating Virtual File System
23. Adding Directory Support in Our VFS
24. Integrating VFS API in Our UI
25. Adding Nested Directory Feature in Our VFS
26. Adding Directory Rename and Delete Functionality
27. Understanding REST API Principles
28. Error Handling in Express
29. Handling File Uploads Using Multer
30. Showing Upload Progress While Using Multer in Backend
31. Adding Basic User Registration Functionality
32. Overview of New UI of Our App
33. What are Cookies?
34. Setting Cookies from Server
35. Implementing Simple Login Functionality
36. Providing User Specific File Access
37. Adding Logout and User Profile Functionality
38. Understanding res.download() Method
39. Using app.route() Method to Clean Our Code
40. Understanding router.param() Method
41. What is HTTP Redirection and How Does it Work?
42. Understanding Different Types of Form Data
43. Difference Between Extended True and False
44. Nested Dynamic Routes
45. RegEx in Routes
46. Using Arrays to Define Multiple Routes
47. Express v4 vs v5

Section 12: Mastering Database Fundamentals with MongoDB

1. Introduction To Database
2. Types Of Databases
3. Introduction To MongoDB
4. Understanding Mongo Shell
5. Installing MongoDB Server
6. MongoDB Fundamentals
7. Creating Documents In MongoDB
8. Reading Data In MongoDB
9. Inspecting MongoDB Data Packages
10. Update Operation In MongoDB
11. Delete Operation In MongoDB
12. Datatypes In MongoDB
13. Object Id Datatype
14. Different Number Types
15. MongoDB Datatypes In Practice
16. BSON Types In MongoDB
17. Where Data Is Stored
18. Configuring Our MongoDB Server
19. Accessing Our MongoDB Server From Anywhere In The World
20. Running MongoShell Scripts in JS Files
21. What is MongoDB Playground?
22. MongoDB in Node.js
23. MongoDB CRUD Operations in Node.js
24. Understanding Cursors in MongoDB
25. Cursor Methods in MongoDB
26. Batch Size in MongoDB
27. Projection in MongoDB
28. Limits of MongoDB
29. MongoDB Setup in Our Storage App
30. Integrating Database in User Routes
31. Integrating Database in Directory Routes
32. Integrating Database in File Routes
33. Performing Bulk Operations in MongoDB
34. Implementing Recursive Directory Delete Functionality
35. Why ObjectId() Is Not a String?
36. Fixing ObjectId() Validation
37. Understanding Application Architecture
38. Ordered Inserts in MongoDB
39. What Is Upsert in MongoDB?
40. Running Commands in MongoDB
41. Operators in MongoDB
42. What Is Schema?
43. Adding Basic Schema Validation in MongoDB
44. Creating a New Collection with Validation Enabled
45. Understanding JSON Schema Validation
46. Validation Action VS Validation Level
47. Finding Invalid Documents in a Collection
48. Adding Schema Validation in Our Storage App
49. Handling Database Validation Errors in Our App
50. What Are Transactions in Database?
51. Implementing Transaction in Code
52. ACID Properties of a Transaction
53. Relational vs. Non-Relational Databases: Key Differences
54. Embedded vs. Referenced Documents: Choosing the Right Data Model
55. Understanding One-to-One, One-to-Many, and Many-to-Many Relationships
56. Backup & Restore Using mongodump and mongoresotre for Backup
57. Using mongoimport and mongoexport to Export and Import JSON or CSV Data
58. mongoimport VS mongoexport: When to Use What?
59. Securing MongoDB: Authentication and Authorization
60. Enabling Auth in MongoDB Replica Set
61. Installing MongoDB On AWS EC2 Ubuntu Instance
62. Deploying MongoDB on EC2
63. Exploring MongoDB Atlas
64. Managed VS Self-Managed Databases

Section 13: Mastering MVC Architecture with Mongoose

1. Introduction to MVC Architecture
2. Controllers in Action: Organizing Your Application Logic
3. Views Explained: Creating and Managing User Interfaces
4. Introduction to Mongoose and Models
5. Mongoose Query Buffering: Queries Wait for Database Connection
6. Schema and Types in Mongoose
7. CRUD Operation Using Mongoose
8. What are Thenable Objects in JavaScript?
9. What is a Mongoose Query?
10. What are Documents in Mongoose?
11. Integrating Mongoose in Our TodoApp
12. Adding Custom Validation in Mongoose Schema
13. Using Ref and Populate to Fetch Referenced Fields
14. Implementing MVC Architecture in StorageApp
15. Integrating Mongoose in UserController
16. Integrating Mongoose in FileController
17. What are Virtuals in Mongoose?
18. Define Custom Methods on Mongoose Documents
19. Define Custom Static Methods on Mongoose Model
20. What Is Middleware in Mongoose?
21. Understanding Document Middleware
22. Understanding Query Middleware
23. Understanding Model Middleware
24. Introduction to Indexes in MongoDB
25. Understanding Unique True Property of Mongoose Schema
26. Creating Unique Index for Email in Our StorageApp
27. Document Versioning in Mongoose
28. Understanding Mongoose Object
29. Mongoose Built-in Error Types ValidationError, MongoServerError, etc.

Section 14: Mastering Authentication and Authorization in Node.js

1. Introduction to Authentication and Authorization
2. Stateful vs Stateless Auth
3. Limitations of Auth in Our Storage App
4. Trying to Fix Cookie Expiry Issue
5. Cryptography Basics: Understanding Encryption vs Hashing
6. Basics of Hashing
7. Hashing in Node.js Using crypto Module
8. How Git Uses Hashing for Commits?
9. Understanding Digital Signatures
10. Signing Cookies in Node.js
11. Understanding MAC and HMAC
12. Signing Cookies Using cookie-parser
13. Hashing Passwords Before Saving to the Database
14. What Are Rainbow Tables?
15. Understanding Key Derivation Functions
16. Using pbkdf2() to Hash Passwords
17. Understanding bcrypt
18. Using bcrypt to Hash Passwords
19. Understanding JSON Web Tokens
20. Do Not Use JWT for Login
21. What Are Sessions?
22. Stateful vs Stateless Servers
23. Overview of Our New LMS App
24. Adding Guest Session in Our LMS App
25. Implementing Cart Functionality
26. Adding Get and Delete Routes for Cart
27. Adding Authorized Sessions in LMS App
28. Moving Cart Data to Cart Collection
29. Implementing Logout and Session Expiry Functionality
30. Auto-Deleting Documents in MongoDB
31. Implementing Sessions in Storage App
32. Restricting Multiple Device Access
33. Implementing Logout from All Devices Functionality
34. Sending Emails Using Node.js
35. Sending Email With Custom Domain
36. Verifying Email Using OTP
37. Understanding OAuth and Its Flow
38. Understanding OpenID Connect and Its Flow
39. Client Registration for Google OAuth Integration
40. Understanding Google’s OpenID Connect
41. How to Open a Popup for Google Login?
42. Creating a Different Page for Redirect URL
43. Implementing Login With Google on Backend
44. Implementing Logout Functionality
45. Receiving Auth Code on Backend
46. Putting Google Auth Redirect Logic in Backend Code
47. Verifying ID Token
48. Using Google Auth Library to Verify ID Token
49. Using Google Auth Library to Fetch ID Token
50. Using Google Auth Library to Generate AuthURL
51. Calling User Info Endpoint With Access Token
52. Customizing OAuth Login Popup With Prompt and Login Hint Parameters
53. Error Handling in Google Login
54. Implementing Google Login With Passport.js
55. Grant Types in OAuth 2.0
56. Understanding Implicit Grant Type
57. Implementing Google Login Using Implicit Grant Type
58. Problem With Implicit Login Flow
59. Enabling One Tap Login and Fixing Implicit Flow Issue
60. GSI vs FedCM
61. Branding Guidelines of Login With Google Button
62. Using GSI Library in React.js
63. Adding Google Login in StorageApp
64. Wrapping Up Authentication – Next Steps & Assignments

Section 15: Understanding Role-Based Access Control (RBAC)

1. What Is RBAC?
2. Implementing GET All Users Endpoint
3. Adding Role-Based Access in Users Route
4. Role-Based UI Rendering
5. Implementing User Logout Functionality
6. Implementing User Delete Feature
7. Implementing Soft Delete for Users
8. Preventing Users from Self-Deletion
9. What is Google Zanzibar and OpenFGA?
10. RBAC Assignments for Storage App

Section 16: Working with Redis – Caching, Session Storage, and Beyond

1. Introduction to Redis
2. Installing Redis: Server, CLI and GUI
3. Data Types in Redis
4. Working with Strings in Redis
5. Time-to-Live (TTL): Expiring Keys in Redis
6. Database Management in Redis
7. Organizing Redis Keys with Namespacing
8. Connecting Redis in Node.js
9. Creating getJSON() and setJSON() Methods
10. Working with RedisJSON Data Type
11. Redis vs MongoDB: Speed Test
12. Using Redis for Caching
13. Using Redis as Session Store
14. Understanding Redis Search and Indexing
15. Fixing Multiple Device Access
16. Working with Redis Search in GUI
17. Exploring Redis Extension for VSCode
18. What is Fuzzy Search in Redis?
19. Understanding SCAN Command in Redis
20. KEYS vs SCAN Command in Redis
21. Working with Redis Lists Data Type
22. Working with Redis Sets Data Type
23. Working with Redis Hashes Data Type
24. Working with Redis Hashes in Node.js
25. Real-Time Messaging with Redis Pub/Sub
26. Enabling Authentication in Redis
27. Understanding Eviction Policies in Redis
28. Exploring Redis Cloud
29. More Topics to Explore in Redis

Section 17: Securing Our Node.js Application

1. Importance of Security in Web Apps
2. Using .env File in Node.js Natively
3. Storing Sensitive Info in .env File
4. Understanding SQL Injection Vulnerability
5. Schema-Based Data Validation With Zod
6. Prevent SQL Injection: Validate User Input With Zod
7. Understanding Same-Origin Policy
8. Hacking the Web: Learn XSS Attacks Practically
9. Fix XSS Vulnerability Using DOMPurify
10. Types of XSS Attacks
11. Understanding Reflected XSS Attack
12. What Is DOM-Based XSS Attack?
13. Understanding Content Security Policy in Depth
14. Reporting CSP Violations
15. Using Inline Scripts With Hash
16. Using Inline Scripts With Nonce
17. Performing Self-XSS Attack Even After CSP Is Enabled
18. What Is Clickjacking?
19. Understanding Domain Attribute in Cookies
20. Understanding Top-Level Navigation
21. Creating Self-Signed HTTPS Server in Node.js
22. Understanding SameSite Cookie Attribute in Depth
23. SameSite Cookies Attribute With Cross-Site Fetch Requests
24. Understanding Cross-Site Request Forgery (CSRF) Attacks
25. Preventing CSRF Attacks With CSRF Tokens
26. Creating a CSRF Token Middleware
27. Preventing CSRF Attacks Using Custom Headers
28. Understanding Denial of Service (DoS) Attack
29. Protecting APIs With Rate Limiting
30. Using express-rate-limit Package
31. Understanding DDoS Attack
32. Important Security Headers You Should Know
33. Using Helmet.js for Adding Security Headers
34. Add API Throttling With Custom Throttle Function
35. Using express-slow-down Package for Throttling
36. Benefits of Throttling
37. Drawbacks of Throttling
38. Dynamic Throttling vs Adaptive Throttling
39. Rate Limiting vs Throttling
40. Searching Security Vulnerabilities in Storage App
41. What Are Dependency Vulnerabilities?
42. More Security Topics to Know

Section 18: Cloud Storage Integration with AWS S3

1. Showing Size of Each File
2. Setting Max File Size Limit
3. Adding Server-Side Validation for Max File Size
4. Implementing Folder Size Feature
5. Adding Total Storage Limit
6. How to Add Path and Breadcrumb Features?
7. Introduction to AWS S3 Bucket
8. Benefits of Using S3 Bucket
9. Serving Files Publicly Using S3 Bucket
10. AWS CLI Introduction and Installation
11. Working with S3 Bucket Using CLI
12. Understanding AWS S3 API Command
13. Managing Bucket Policy Using S3 API
14. What Is AWS CloudShell?
15. Understanding Signed URL in S3
16. Identity and Access Management (IAM) in AWS
17. What Are User Groups in IAM?
18. Understanding IAM Policies
19. Understanding IAM Roles
20. AWS S3 SDK Setup in Node.js
21. S3 CRUD Operations Using Node.js
22. Showing S3 Upload Progress in Node.js
23. Creating GET and PUT Signed URLs Using Node.js
24. Creating Signed URLs Using AWS Presigner Library
25. S3 Storage Classes and Pricing
26. Delivering Content at Lightning Speed with CloudFront CDN
27. Cache Invalidation in CloudFront
28. Securing Files with CloudFront Signed URLs
29. Comparing CloudFront Pricing with S3 Pricing
30. Preparing Our StorageApp for S3 Bucket Integration
31. Uploading to S3 from Browser (CORS Enabled)
32. Integrating S3 Bucket in StorageApp – File Uploads
33. Integrating S3 Bucket in StorageApp – File Downloads
34. Implementing Upload Complete Endpoint for File Verification
35. Implementing Delete Feature for S3 Files
36. Integrating CloudFront in StorageApp

Section 19: Razorpay and Stripe Payment Gateway Integration

1. Designing Subscription-Based Storage Plans
2. Updating User Schema to Support Plans and Limits
3. Creating Plan Selection UI in Dashboard
4. Overview of Razorpay and Its Use Cases
5. Creating Razorpay Account and Getting API Keys
6. Integrating Razorpay Checkout in Frontend
7. Handling Razorpay Payment Verification in Backend
8. Updating User Storage Limit After Razorpay Payment
9. Overview of Stripe and Why It’s Used Globally
10. Creating Stripe Account and API Keys
11. Using Stripe Checkout Flow
12. Handling Stripe Webhooks to Confirm Payments
13. Updating User Plan and Quota on Stripe Events
14. Difference Between One-Time Payments and Subscriptions
15. Creating Subscription Logic in Backend
16. Auto-Renewal Strategy (If Applicable)
17. Notifying Users on Plan Expiry or Low Quota
18. Implementing Webhooks for Payment Gateways
19. Sending Emails on Payment Success or Failure
20. Preventing Uploads If Plan Has Expired or Payment Failed

Section 20: Deploying Node.js Applications and CI/CD

1. Understanding the Deployment Process
2. Setting Up a Production Environment
3. Configuring Environment Variables
4. Managing Secrets and Sensitive Data
5. Basic Server Setup for Node.js
6. Installing Node.js and npm on a Server
7. Starting and Managing Node.js Processes with PM2
8. Deploying to Cloud Platforms
9. Deploying a Node.js App to AWS (EC2) and DigitalOcean
10. Introduction to CI/CD
11. Understanding Continuous Integration and Continuous Deployment
12. Basic CI/CD Pipeline Setup

Section 21: Introduction to Docker & Containerization

1. Introduction to Docker and Containerization
2. What Is Containerization and Why Use It?
3. Virtual Machines vs. Containers: Key Differences
4. Understanding Docker's Role in Modern Development
5. Installing Docker and Setting Up the Environment
6. Docker Basics for Node.js Applications
7. What Is a Docker Image and a Container?
8. Understanding and Writing a Dockerfile
9. Building and Running a Node.js Application in a Docker Container
10. Essential Docker Commands: docker ps, docker images, docker logs, and More
11. Working with Docker Compose for Multi-Container Applications
12. What Is Docker Compose and Why Use It?
13. Writing a docker-compose.yml File
14. Running Node.js and MongoDB Together in Docker
15. Using Docker Networks for Service Communication
16. Managing Persistent Data in Docker
17. Understanding Docker Volumes and Bind Mounts
18. Persisting Database Data Using Volumes
19. Hot-Reloading a Node.js App Inside a Container
20. Optimizing Docker Images for Better Performance
21. Reducing Image Size with Multi-Stage Builds
22. Using .dockerignore to Improve Build Efficiency
23. Best Practices for Writing Efficient Dockerfiles
24. Container Networking and Security
25. Understanding Docker Networking: Bridge, Host, and Overlay Networks
26. Running Multiple Services in Containers with Custom Networks
27. Securing Node.js Applications in Docker Containers
28. Managing Environment Variables in Docker
29. Deploying Dockerized Node.js Applications
30. Deploying a Docker Container to a Cloud Server (AWS, DigitalOcean, etc.
31. Hosting a Dockerized Node.js Application Using Nginx as a Reverse Proxy
32. CI/CD Integration with Docker: Connecting with GitHub Actions, Jenkins, etc.
33. Introduction to Kubernetes for Container Orchestration
34. Why Kubernetes? Basics of Container Orchestration
35. Deploying a Simple Node.js Application on Kubernetes
36. Kubernetes vs. Docker Compose: When to Use What?