Technical Interview Preparation Guide

Core CS Fundamentals: DBMS • OS • Computer Networks • System Design • AWS

This guide compiles the most frequently asked interview questions across five core technical areas, each with a
concise model answer. Use it as a revision sheet before your interview — read each answer once, then try
explaining it out loud in your own words.

1. Database Management Systems (DBMS) 15 Questions

2. Operating Systems (OS) 15 Questions

3. Computer Networks (CN) 15 Questions

4. System Design 12 Questions

5. AWS / Cloud 12 Questions

Page 1
 1. Database Management Systems (DBMS)
Q1. What is the difference between DBMS and RDBMS?

A DBMS is software for storing and managing data (e.g., files, hierarchical or network databases). An RDBMS is a
type of DBMS that stores data in tables with rows and columns, enforces relationships through primary/foreign keys,
and supports SQL, ACID transactions, and normalization. All RDBMS are DBMS, but not all DBMS are relational
(e.g., MongoDB is a non-relational DBMS).

Q2. Explain normalization and describe 1NF, 2NF, 3NF, and BCNF.

Normalization organizes data to reduce redundancy and avoid update/insert/delete anomalies. 1NF requires atomic
column values (no repeating groups). 2NF requires 1NF plus no partial dependency — every non-key column
depends on the whole primary key. 3NF requires 2NF plus no transitive dependency — non-key columns depend
only on the key, not on other non-key columns. BCNF is a stricter version of 3NF where every determinant must be
a candidate key.

Q3. What are ACID properties?

Atomicity: a transaction either fully completes or fully rolls back. Consistency: a transaction takes the database from
one valid state to another, respecting constraints. Isolation: concurrent transactions don't interfere with each other's
intermediate results. Durability: once committed, changes survive system crashes (usually via write-ahead logs).

Q4. What is the difference between primary key, unique key, and foreign key?

A primary key uniquely identifies each row, cannot be NULL, and a table can have only one. A unique key also
enforces uniqueness but can allow one NULL value and a table can have multiple. A foreign key is a column that
references the primary key of another table, enforcing referential integrity between tables.

Q5. Explain the different types of joins in SQL.

INNER JOIN returns only matching rows from both tables. LEFT JOIN returns all rows from the left table plus
matches from the right (NULL if none). RIGHT JOIN is the mirror of LEFT JOIN. FULL OUTER JOIN returns all rows
from both, matched where possible. SELF JOIN joins a table to itself. CROSS JOIN returns the Cartesian product of
both tables.

Q6. What is indexing and how does it improve performance?

An index is a data structure (typically a B-Tree or B+Tree) built on one or more columns that lets the database find
rows without scanning the whole table, similar to a book's index. It drastically speeds up SELECT/search queries,
but adds overhead to INSERT/UPDATE/DELETE since the index must also be updated, and consumes extra
storage.

Q7. What is the difference between clustered and non-clustered index?

A clustered index determines the physical order of data rows in the table — there can be only one per table, usually
on the primary key. A non-clustered index is a separate structure that stores pointers to the actual data rows, so a

Page 2
table can have multiple non-clustered indexes.

Q8. Explain database transactions and isolation levels.

A transaction is a sequence of operations executed as a single logical unit. Isolation levels control how visible one
transaction's changes are to others: Read Uncommitted (lowest, allows dirty reads), Read Committed (no dirty
reads), Repeatable Read (no dirty or non-repeatable reads), and Serializable (highest, fully isolated, prevents
phantom reads too, but slowest).

Q9. What are dirty read, non-repeatable read, and phantom read?

A dirty read happens when a transaction reads uncommitted data from another transaction that may later be rolled
back. A non-repeatable read happens when a row is read twice in the same transaction and its value changes in
between due to another committed transaction. A phantom read happens when a query run twice returns a different
set of rows because another transaction inserted or deleted rows in between.

Q10. What is a deadlock in DBMS and how can it be prevented?

A deadlock occurs when two or more transactions wait indefinitely for each other to release locks, forming a circular
wait. It can be prevented by acquiring locks in a consistent global order, using lock timeouts, or using detection
algorithms (wait-for graphs) that abort one transaction to break the cycle.

Q11. Explain the difference between SQL and NoSQL databases.

SQL databases are relational, have a fixed schema, and typically scale vertically while providing strong ACID
consistency (e.g., MySQL, PostgreSQL). NoSQL databases are non-relational, have flexible/dynamic schemas, and
scale horizontally across servers, often trading strict consistency for availability and partition tolerance (e.g.,
MongoDB, Cassandra, DynamoDB) — following the BASE model instead of ACID.

Q12. What is a stored procedure and what are its advantages?

A stored procedure is a precompiled block of SQL code stored in the database that can be called by name.
Advantages include reduced network traffic (one call instead of many queries), improved performance since it's
precompiled, better security (users can execute logic without direct table access), and reusability across
applications.

Q13. What is the difference between DELETE, TRUNCATE, and DROP?

DELETE removes rows one at a time, is logged, can be rolled back, and can use a WHERE clause. TRUNCATE
removes all rows at once, is minimally logged, faster, and generally cannot be rolled back in most databases, but
keeps the table structure. DROP removes the entire table structure along with its data permanently.

Q14. Explain database sharding and replication.

Sharding is horizontal partitioning — splitting a large dataset across multiple database servers (shards) based on a
key, so each server holds a subset of the data, improving write scalability. Replication is copying the same data
across multiple servers (a primary and one or more replicas) to improve read scalability and provide fault

Page 3
tolerance/high availability.

Q15. What is a view in SQL and why would you use one?

A view is a virtual table defined by a SQL query; it doesn't store data itself but presents data from one or more
underlying tables. Views are used to simplify complex queries, restrict access to specific columns/rows for security,
and provide a consistent interface even if the underlying schema changes.

Page 4
 2. Operating Systems (OS)
Q1. What is the difference between a process and a thread?

A process is an independent program in execution with its own memory space, resources, and address space. A
thread is the smallest unit of execution within a process; threads of the same process share memory and resources
but have their own stack and registers. Threads are lighter and cheaper to create/switch than processes.

Q2. Explain the different process scheduling algorithms.

FCFS (First Come First Served) executes processes in arrival order — simple but can cause long waits (convoy
effect). SJF (Shortest Job First) picks the shortest burst time next, minimizing average wait time but risking
starvation. Round Robin assigns each process a fixed time slice cyclically — fair and good for time-sharing systems.
Priority Scheduling runs the highest-priority process first, which can also cause starvation, often solved with aging.

Q3. What is a deadlock? Explain the four necessary conditions.

A deadlock is a state where a set of processes are blocked because each is waiting for a resource held by another.
The four Coffman conditions required for deadlock are: Mutual Exclusion (resources can't be shared), Hold and Wait
(a process holds one resource while waiting for another), No Preemption (resources can't be forcibly taken), and
Circular Wait (a cycle of processes each waiting on the next).

Q4. How can deadlocks be prevented, avoided, and detected?

Prevention breaks one of the four necessary conditions (e.g., forcing processes to request all resources at once).
Avoidance uses algorithms like the Banker's Algorithm to only grant requests that keep the system in a safe state.
Detection allows deadlocks to occur but periodically checks for cycles in a resource-allocation graph and recovers
by killing or rolling back a process.

Q5. What is a race condition and how do you prevent it?

A race condition occurs when multiple threads/processes access shared data concurrently and the final outcome
depends on the timing of execution, leading to unpredictable results. It's prevented by synchronizing access to the
shared resource using mutexes, semaphores, or critical sections so only one thread modifies the data at a time.

Q6. Explain the difference between a mutex and a semaphore.

A mutex is a locking mechanism with ownership — only the thread that locked it can unlock it, and it allows only one
thread into the critical section. A semaphore is a signaling mechanism with a counter that can allow a fixed number
of threads to access a resource simultaneously (counting semaphore), and doesn't have strict ownership — any
thread can signal it.

Q7. What is virtual memory and why is it used?

Virtual memory is an abstraction that gives each process the illusion of a large, contiguous private address space,
independent of physical RAM size. It's implemented using paging/segmentation with disk-backed swap space,
allowing more processes to run than would fit in physical memory, and providing memory protection and isolation

Page 5
between processes.

Q8. Explain paging and segmentation.

Paging divides memory into fixed-size blocks called pages (logical) and frames (physical); it eliminates external
fragmentation but can cause internal fragmentation. Segmentation divides a program into variable-sized logical units
(code, stack, heap) that map more naturally to how programs are structured, but can suffer from external
fragmentation.

Q9. What is thrashing in an operating system?

Thrashing occurs when a system spends more time swapping pages in and out of memory (handling page faults)
than executing actual processes, usually because too many processes are competing for too little physical memory.
It severely degrades performance and is typically resolved by reducing the degree of multiprogramming or adding
more RAM.

Q10. What is the difference between multiprogramming, multitasking, and multithreading?

Multiprogramming means multiple programs reside in memory so the CPU always has something to execute,
maximizing CPU utilization. Multitasking extends this by rapidly switching between tasks so users perceive them as
running simultaneously. Multithreading means multiple threads run within a single process, sharing resources but
executing independently.

Q11. Explain the producer-consumer problem.

It's a classic synchronization problem where a 'producer' generates data into a fixed-size shared buffer and a
'consumer' removes it, and both must be synchronized so the producer doesn't add to a full buffer and the consumer
doesn't remove from an empty one. It's solved using semaphores (empty/full counters) or condition variables
combined with a mutex to protect the buffer.

Q12. What are system calls? Give examples.

System calls are the programmatic interface that lets user-space applications request services from the OS kernel,
such as accessing hardware or managing processes. Examples include fork() to create a process, exec() to run a
new program, read()/write() for I/O, and wait() to pause until a child process finishes.

Q13. What is context switching and what is its overhead?

Context switching is the process of saving the state (registers, program counter, memory maps) of a currently
running process/thread and loading the state of another so the CPU can switch execution. The overhead includes
the CPU cycles spent saving/restoring state and cache/TLB invalidation, during which no actual user work is
performed.

Q14. What is the difference between a monolithic kernel and a microkernel?

A monolithic kernel runs all OS services (file system, drivers, networking) in kernel space as a single large program,
which is fast but less modular and a bug can crash the whole system. A microkernel keeps only essential services

Page 6
(IPC, basic scheduling, memory management) in kernel space and runs other services in user space, making it
more modular and stable but with higher communication overhead.

Q15. What is a page fault and how is it handled?

A page fault occurs when a process accesses a page that isn't currently loaded in physical memory. The OS
handling it: pauses the process, locates the page on disk, finds a free frame (or evicts one using a replacement
algorithm like LRU, FIFO, or Optimal), loads the page into that frame, updates the page table, and resumes the
process.

Page 7
 3. Computer Networks (CN)
Q1. Explain the OSI model and its 7 layers.

The OSI model standardizes network communication into 7 layers: Physical (raw bit transmission over hardware),
Data Link (framing, MAC addressing, error detection), Network (logical addressing/routing via IP), Transport
(end-to-end delivery, TCP/UDP), Session (managing connections/sessions), Presentation (data formatting,
encryption, compression), and Application (user-facing protocols like HTTP, FTP).

Q2. What is the difference between TCP and UDP?

TCP is connection-oriented, establishes a handshake, guarantees reliable, ordered delivery with error checking and
retransmission — used for web browsing, email, file transfer. UDP is connectionless, sends data without guarantees
of delivery or order, but is faster and has lower overhead — used for video streaming, gaming, and DNS where
speed matters more than reliability.

Q3. Explain the TCP three-way handshake.

It's the process to establish a reliable TCP connection: the client sends a SYN (synchronize) packet to the server;
the server responds with SYN-ACK (acknowledging and synchronizing back); the client sends an ACK to confirm.
After this, both sides agree on sequence numbers and the connection is established for data transfer.

Q4. What happens when you type a URL into a browser?

The browser checks its cache, then performs a DNS lookup to resolve the domain to an IP address. It establishes a
TCP connection (three-way handshake) and, for HTTPS, a TLS handshake to negotiate encryption. The browser
sends an HTTP request; the server processes it and sends back an HTTP response, which the browser then parses
and renders, fetching additional resources (CSS, JS, images) as needed.

Q5. What is DNS and how does domain name resolution work?

DNS (Domain Name System) is a hierarchical, distributed system that translates human-readable domain names
into IP addresses. Resolution flows from the browser/OS cache, to a recursive resolver, then to root servers, then
TLD servers (e.g., .com), and finally the authoritative name server for the domain, which returns the IP address.

Q6. Explain the difference between HTTP and HTTPS.

HTTP transmits data in plain text between client and server, making it vulnerable to eavesdropping and tampering.
HTTPS adds a layer of TLS/SSL encryption on top of HTTP, encrypting the data in transit and using certificates to
verify the server's identity, protecting against man-in-the-middle attacks.

Q7. What is the difference between a hub, switch, and router?

A hub is a basic device that broadcasts incoming data to all connected ports regardless of destination, operating at
the physical layer. A switch operates at the data link layer and intelligently forwards data only to the port matching
the destination MAC address. A router operates at the network layer and forwards data between different networks
based on IP addresses.

Page 8
 Q8. What is subnetting and why is it used?

Subnetting divides a large network into smaller logical sub-networks (subnets) by borrowing bits from the host
portion of an IP address for the network portion. It's used to improve network performance and security by reducing
broadcast domains, and to make more efficient use of IP address space.

Q9. Explain the difference between IPv4 and IPv6.

IPv4 uses 32-bit addresses (about 4.3 billion addresses), written in dotted-decimal notation (e.g., [Link]), and
address exhaustion has become a real issue. IPv6 uses 128-bit addresses, written in hexadecimal, providing a
vastly larger address space, along with simplified headers, built-in support for auto-configuration, and no need for
NAT.

Q10. What is NAT (Network Address Translation)?

NAT is a technique that maps private IP addresses used within a local network to a single public IP address (or a
small pool) when communicating with the internet, and vice versa for incoming responses. It allows many devices to
share one public IP, conserving IPv4 addresses and adding a layer of obscurity/security for internal devices.

Q11. What is the difference between a firewall and a proxy server?

A firewall monitors and filters incoming/outgoing network traffic based on predefined security rules (IP, port,
protocol) to block unauthorized access. A proxy server acts as an intermediary between a client and the destination
server, forwarding requests on the client's behalf — it can provide anonymity, caching, and content filtering, but isn't
primarily a security barrier like a firewall.

Q12. Explain congestion control in TCP.

TCP congestion control prevents overwhelming the network by dynamically adjusting the sender's window size. It
starts with Slow Start (exponentially increasing window until a threshold), moves to Congestion Avoidance (linear
increase), and on packet loss uses Fast Retransmit/Fast Recovery to quickly recover without a full restart, reducing
the window to avoid further congestion.

Q13. What are sockets and how do they work?

A socket is an endpoint for network communication, identified by a combination of an IP address and a port number.
Applications create a socket, bind it (for servers) or connect it (for clients), and then send/receive data through it —
the OS handles the underlying transport of that data using TCP or UDP.

Q14. What is the difference between symmetric and asymmetric encryption?

Symmetric encryption uses a single shared secret key for both encryption and decryption — it's fast but requires
securely sharing the key beforehand (e.g., AES). Asymmetric encryption uses a public/private key pair — data
encrypted with the public key can only be decrypted with the private key — it's slower but solves the key-distribution
problem (e.g., RSA), and is used in TLS handshakes to safely exchange a symmetric session key.

Page 9
 Q15. Explain load balancing and common load balancing algorithms.

Load balancing distributes incoming network traffic across multiple servers to prevent any single server from being
overwhelmed, improving availability and responsiveness. Common algorithms include Round Robin (cycles through
servers sequentially), Least Connections (routes to the server with fewest active connections), and IP Hash (routes
based on a hash of the client's IP, useful for session persistence).

Page 10
 4. System Design
Q1. How would you design a URL shortener (like [Link])?

Generate a short unique key (via base62 encoding of an auto-incremented ID, or a hash with collision handling) and
store a mapping of short_key -> long_url in a database. Since reads (redirects) far outnumber writes, add a caching
layer (Redis) in front of the DB and use a fast key-value lookup for redirection with an HTTP 301/302. Consider
custom aliases, expiration, and analytics as extensions.

Q2. How do you design a scalable rate limiter?

Common algorithms: Token Bucket (tokens refill at a fixed rate, requests consume tokens, allows bursts), Leaky
Bucket (processes requests at a fixed rate, smooths bursts), and Sliding Window Log/Counter (tracks request
counts in a rolling time window for accuracy). For a distributed system, store counters in a fast shared store like
Redis with atomic increment and TTL so all servers share the same rate-limit state.

Q3. What is the difference between horizontal and vertical scaling?

Vertical scaling means adding more resources (CPU, RAM) to a single existing machine — simple but has a
hardware ceiling and creates a single point of failure. Horizontal scaling means adding more machines/instances
and distributing load across them — more complex (requires load balancing, data partitioning) but offers
near-limitless scalability and better fault tolerance.

Q4. Explain the CAP theorem.

CAP theorem states that a distributed system can only guarantee two of three properties during a network partition:
Consistency (all nodes see the same data at the same time), Availability (every request gets a response, even if not
the latest data), and Partition Tolerance (the system keeps working despite network failures between nodes). Since
partitions are inevitable in distributed systems, real systems choose between CP (e.g., HBase) and AP (e.g.,
Cassandra, DynamoDB).

Q5. How would you design a news feed system (like Facebook/Twitter)?

Two main approaches: Fan-out on write (when a user posts, push the post into all followers' feed caches
immediately — fast reads, expensive for users with millions of followers) and Fan-out on read (build the feed
dynamically when a user requests it by pulling posts from everyone they follow — cheaper writes, slower reads).
Most large systems use a hybrid, plus caching, pagination, and a ranking algorithm to order posts by relevance
rather than just chronologically.

Q6. What is a load balancer and where would you place it in your architecture?

A load balancer distributes incoming client requests across multiple backend servers to prevent overload and
improve availability, typically performing health checks to route traffic only to healthy instances. It sits between the
client (or DNS) and the application server tier — and in larger systems, load balancers can also be placed between
the app tier and database read replicas.

Page 11
 Q7. How do you handle database scaling for a high-traffic application?

Start with read replicas to offload read traffic from the primary database. Add a caching layer (Redis/Memcached)
for frequently accessed data to reduce DB load. For write-heavy workloads, use sharding to horizontally partition
data across multiple database servers by a key (e.g., user ID). Also use connection pooling to efficiently reuse DB
connections.

Q8. What is caching and what are common caching strategies?

Caching stores frequently accessed data in a fast-access layer (in-memory) to reduce latency and load on the
primary data store. Cache-aside: application checks cache first, loads from DB on a miss and populates cache.
Write-through: writes go to cache and DB simultaneously, keeping them in sync. Write-back: writes go to cache first
and are asynchronously flushed to DB, faster but risks data loss. Eviction policies like LRU (Least Recently Used)
manage cache size.

Q9. How would you design a chat application (like WhatsApp)?

Use WebSockets (or long polling) for real-time bidirectional communication between clients and servers. Route
messages through a message broker/queue for reliable delivery and to decouple sender and receiver. Store
message history in a database optimized for writes (e.g., Cassandra), track delivery/read receipts with status flags,
and use presence servers to track online/offline status.

Q10. What is the difference between message queues and pub-sub systems?

A message queue (e.g., Amazon SQS, RabbitMQ) delivers each message to exactly one consumer — used for
point-to-point task distribution and decoupling producers from consumers. A pub-sub system (e.g., Amazon SNS,
Kafka) broadcasts each message to all subscribed consumers — used for fan-out scenarios like notifying multiple
services of an event.

Q11. How do you ensure high availability in a distributed system?

Use redundancy by running multiple instances of each service across different servers/Availability Zones, with
automatic failover if one goes down. Use health checks and load balancers to route traffic away from unhealthy
nodes. Replicate data across regions/zones, and design for graceful degradation so partial failures don't bring down
the whole system.

Q12. What is database replication lag and how do you handle it?

Replication lag is the delay between a write being committed on the primary database and that change being
reflected on read replicas, caused by network latency or replica load. It's handled by routing read-your-own-write
queries to the primary (or waiting for replica sync), designing the application to tolerate eventual consistency where
acceptable, and monitoring lag to alert if it grows too large.

Page 12
 5. AWS / Cloud
Q1. What is the difference between EC2, Lambda, and ECS/EKS?

EC2 provides virtual machines you fully manage (OS, scaling, patching) — best for long-running, custom workloads.
Lambda is serverless compute that runs code in response to events without managing servers, automatically scales,
and you pay only for execution time — best for short, event-driven tasks. ECS/EKS run containerized applications
(Docker) with orchestration for scaling and deployment — ECS is AWS-native, EKS is managed Kubernetes.

Q2. Explain the difference between S3 storage classes.

S3 Standard is for frequently accessed data with low latency and high durability. S3 Infrequent Access (IA) costs
less for storage but charges a retrieval fee, ideal for data accessed occasionally. S3 Glacier (and Glacier Deep
Archive) is the cheapest, meant for long-term archival where retrieval can take minutes to hours. The right class
trades off storage cost vs retrieval cost/speed.

Q3. What is an IAM role vs an IAM user vs an IAM policy?

An IAM user is an identity representing a person or application with long-term credentials. An IAM role is an identity
with temporary permissions that can be assumed by users, applications, or AWS services (e.g., an EC2 instance
assuming a role to access S3) — no long-term credentials needed. An IAM policy is a JSON document that defines
what actions are allowed or denied on which resources, attached to users, roles, or groups.

Q4. What is the difference between a security group and a NACL?

A Security Group is a stateful virtual firewall at the instance level — if you allow inbound traffic, the outbound
response is automatically allowed. A Network ACL (NACL) is a stateless firewall at the subnet level — you must
explicitly allow both inbound and outbound rules, and rules are evaluated in order by rule number.

Q5. Explain the difference between horizontal scaling using Auto Scaling Groups and Elastic
Load Balancer.

An Auto Scaling Group (ASG) automatically adds or removes EC2 instances based on demand (CPU usage,
request count, schedules) to maintain performance and control cost. An Elastic Load Balancer (ELB) sits in front of
these instances and distributes incoming traffic evenly across them, and works together with the ASG's health
checks to route traffic only to healthy instances.

Q6. What is a VPC and what are its core components?

A VPC (Virtual Private Cloud) is an isolated, logically separated section of the AWS cloud where you can launch
resources in a defined virtual network. Core components include subnets (public/private segments of the VPC),
route tables (control traffic routing), an Internet Gateway (allows internet access for public subnets), and a NAT
Gateway (allows private subnet resources to reach the internet without being publicly reachable).

Q7. What is the difference between RDS and DynamoDB?

Page 13
RDS is a managed relational database service (supports MySQL, PostgreSQL, etc.) with structured schemas, SQL
queries, and ACID transactions — good for complex relational data and joins. DynamoDB is a fully managed NoSQL
key-value/document database designed for massive horizontal scale, single-digit millisecond latency, and flexible
schemas — good for high-throughput, simple-access-pattern workloads.

Q8. Explain how Amazon S3 achieves durability and availability.

S3 automatically and synchronously replicates data across multiple physically separated Availability Zones within a
region, giving it 99.999999999% (11 nines) durability. Availability is achieved through this redundancy plus AWS's
distributed infrastructure, though availability SLAs (e.g., 99.9%) are typically lower than durability guarantees since
durability concerns not losing data, while availability concerns being able to access it at any moment.

Q9. What is AWS Lambda and what are its use cases?

AWS Lambda is a serverless compute service that runs your code in response to triggers (API calls, S3 events,
schedule, queue messages) without provisioning or managing servers, and automatically scales with the number of
incoming events. Common use cases include image/file processing on upload, backend APIs (with API Gateway),
data transformation pipelines, and scheduled/cron-like tasks.

Q10. What is the difference between SQS and SNS?

SQS (Simple Queue Service) is a pull-based message queue where messages are stored until a consumer polls
and processes them, one consumer per message — good for decoupling and buffering work between services. SNS
(Simple Notification Service) is a push-based pub-sub service that broadcasts a message to multiple subscribers
(email, SQS queues, Lambda) simultaneously — good for fan-out notification patterns.

Q11. How does AWS CloudFront improve application performance?

CloudFront is AWS's Content Delivery Network (CDN) — it caches copies of your content (static assets, even
dynamic content) at edge locations physically closer to end users around the world. This reduces latency by serving
requests from a nearby edge rather than the origin server, and also reduces load on the origin infrastructure.

Q12. What is the shared responsibility model in AWS?

It defines the division of security responsibilities between AWS and the customer. AWS is responsible for 'security of
the cloud' — the physical infrastructure, hardware, networking, and the software that runs the underlying services.
The customer is responsible for 'security in the cloud' — configuring IAM permissions correctly, encrypting their
data, managing OS/application patches (for EC2), and securing their applications.

Quick tip: Don't just memorize these answers word-for-word — be ready to connect each concept to a real
project where you applied it. Interviewers love hearing 'I used X because Y.' Good luck tomorrow!

Page 14