TL;DR: A pod is one or more containers that share a network namespace, an IP address and optionally storage, scheduled together onto one node and living and dying as a unit. Kubernetes needs that unit because some containers only make sense running beside another one on the same machine.
How to approach it
Answer the "why" before the "what". Anyone can recite that a pod is the smallest deployable unit; the interesting part is what the containers inside one share, because that is the reason the abstraction exists at all. Then give one real case where you would put two containers in a pod, and one where you would not.
A strong answer
Containers inside a pod share three things.
A network namespace, so they share an IP address and a port range. Two containers in the same pod reach each other on localhost, and they cannot both bind port 8080. From outside, the pod has one address.
Storage, when you mount the same volume into both. An emptyDir volume is the usual way one container writes a file and another reads it.
A lifetime and a node. They are scheduled together, they are never split across machines, and deleting the pod deletes all of them.
The reason this abstraction exists is that certain things are genuinely one unit. A service and its log shipper. An application and a proxy handling its TLS. A container that fetches configuration from a remote store and writes it to a volume before the main process starts, which is what an init container is: it runs to completion first, and the main containers do not start until it exits successfully.
The rule for when to add a second container: only when it must be on the same machine as the first, and only when it makes no sense to scale the two separately. A proxy handling every request for one application qualifies. A background job that happens to be written by the same team does not, because scaling the application would scale the job with it, and you almost never want that.
Worth saying out loud: you rarely create a pod directly. You create a Deployment, and it creates a ReplicaSet, which creates pods. A bare pod has nothing watching it, so when the node it is on dies, it is simply gone. That fact catches people out, because kubectl run produces exactly that.
One more thing beginners find surprising: every pod has an extra container you never declared, called the pause container. It does nothing but hold the network namespace open, so the other containers can restart without the pod losing its IP.
What interviewers probe next
"What happens to a pod's IP when it restarts?" A container restarting inside the pod keeps the IP. The pod being replaced gets a new one, which is why nothing should ever address a pod by IP and why Services exist.
"Can containers in different pods share a volume?" Not an emptyDir. They can share a PersistentVolume if its access mode allows more than one writer, and most block storage does not.
"When does a pod restart versus get replaced?" A container crashing is restarted in place by the kubelet, and the restart count goes up. A pod being evicted, or its node failing, means a new pod with a new name and a new IP.
Common mistakes
Saying a pod is "a wrapper around a container" and stopping, which explains nothing about why it exists.
Putting several unrelated containers in one pod because they belong to the same feature, then being unable to scale or update either independently.
Creating bare pods for anything real, so nothing recreates them after a node failure.
Assuming two containers in a pod can both listen on the same port. They share the network namespace, so the second one fails to bind.