Most computer vision interviews cover three distinct skill areas simultaneously: classical image processing, deep learning architecture, and production systems design. Most candidates prepare for one and get caught off guard by the other two during the loop.
Whether you're targeting a role at a self-driving car company, a medical imaging startup, or a team building content moderation at scale, the technical bar is consistent enough that preparation follows a recognizable pattern. This guide covers the computer vision interview questions you'll actually encounter—organized by round type—and what interviewers are trying to assess when they ask them.
What Computer Vision Interviews Actually Cover
A typical computer vision engineering interview loop breaks into four areas:
- Coding — LeetCode-style algorithmic problems plus CV-specific implementations (IoU, NMS, convolution from scratch)
- ML theory — Architecture knowledge, training dynamics, loss functions, evaluation metrics
- System design — End-to-end pipeline design for a real CV use case under production constraints
- Domain depth / behavioral — How you've applied CV in prior work, how you debug model failures
The ratio varies by company. A FAANG role will weight LeetCode and system design heavily. A startup focused on autonomous systems goes deeper on sensor fusion and real-time inference. A research position spends more time on conceptual questions at the paper level.
Most candidates underestimate the implementation round. Being able to talk about IoU is different from writing it correctly on a whiteboard in ten minutes without access to documentation.
Common Computer Vision Interview Questions: Concepts and Theory
These questions test fundamental understanding. Interviewers aren't looking for definitions—they want to see how you reason about tradeoffs and edge cases.
What is convolution, and why do CNNs use it instead of fully connected layers?
The answer interviewers want centers on weight sharing and spatial invariance. A convolutional filter applies the same weights across the entire input, reducing parameter count dramatically. A 3×3 filter requires 9 weights regardless of input size; a fully connected layer on a 224×224 image would require millions of parameters just for the first layer. The spatial structure of images—nearby pixels are correlated—makes convolution a natural fit. Follow-up: explain the difference between convolution and cross-correlation (most frameworks implement the latter and call it convolution).
What's the difference between semantic, instance, and panoptic segmentation?
- Semantic segmentation: Every pixel gets a class label, but objects of the same class aren't individually distinguished
- Instance segmentation: Individual object instances are identified, but background pixels are not labeled
- Panoptic segmentation: Every pixel is labeled, and individual instances within the same class are distinguished
Know which task fits which use case—autonomous driving needs panoptic, industrial defect detection often only needs semantic.
Explain non-maximum suppression. What are its failure modes?
Object detectors generate multiple overlapping bounding boxes for the same object. NMS selects the highest-confidence box, suppresses all other boxes overlapping it above an IoU threshold (typically 0.5), and repeats. The main failure mode: two objects of the same class that are close together. NMS can incorrectly suppress the second detection when their boxes overlap significantly. Soft-NMS addresses this by decaying scores rather than hard-suppressing them.
What causes vanishing gradients in deep networks, and how does ResNet address it?
As gradients flow backward through many layers, repeated multiplication by values less than one (from saturating activations like sigmoid) shrinks them toward zero—early layers learn extremely slowly or not at all. ResNet introduces skip connections that add the block input directly to its output. This creates a gradient shortcut: the error signal can flow to earlier layers without passing through the entire chain of nonlinearities. It also makes the optimization landscape smoother.
How do you handle class imbalance in a computer vision dataset?
Common approaches: oversampling the minority class, undersampling the majority, using weighted loss functions (assign higher loss to rare classes), or focal loss—which down-weights well-classified examples so the model focuses on hard negatives. The right choice depends on how severe the imbalance is and whether the rare class examples are already scarce in the training set (in which case generating more data via augmentation may be better than subsampling the majority).
Computer Vision Interview Questions: Deep Learning Architectures
When would you choose EfficientNet over ResNet?
EfficientNet scales width, depth, and resolution simultaneously using a compound coefficient found by neural architecture search. For accuracy-per-parameter efficiency—particularly on mobile or edge hardware—EfficientNet typically wins. ResNet remains dominant in production because the codebase is mature, behavior is predictable, and most practitioners know exactly how to debug it. If model size is the primary constraint, EfficientNet or MobileNet variants are the right call. If operational simplicity matters more, ResNet.
Explain the U-Net architecture. Why is it used in medical imaging?
U-Net has a contracting encoder path and an expansive decoder path connected by skip connections that copy feature maps from encoder to decoder at each scale. These skip connections let the network recover fine-grained spatial information lost during downsampling. In medical imaging, precise localization is the entire point—you need to know not just that a lesion exists but its exact boundaries. U-Net's ability to combine high-level semantic features with high-resolution spatial detail makes it the default choice for segmentation tasks where pixel-level accuracy matters.
What is a feature pyramid network and when is it necessary?
An FPN builds a multi-scale feature hierarchy by combining deep features (high semantic content, low resolution) with shallow features (low semantic content, high resolution) using lateral connections and upsampling. This is critical for detecting objects at very different scales in the same image—something a single-scale feature map handles poorly. Small objects are often invisible at deep feature map resolutions; large objects lack context at shallow ones. Modern YOLO and Faster R-CNN variants both use FPN-style multi-scale processing.
The Coding Round: What to Implement
Practice these by hand. No autocomplete, no documentation lookup.
IoU calculation
Calculate the overlap between two bounding boxes. The common mistake is getting intersection coordinates wrong—you need max for the top-left corner and min for the bottom-right:
def iou(box1, box2):
x1 = max(box1[0], box2[0])
y1 = max(box1[1], box2[1])
x2 = min(box1[2], box2[2])
y2 = min(box1[3], box2[3])
intersection = max(0, x2 - x1) * max(0, y2 - y1)
area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
return intersection / (area1 + area2 - intersection)2D convolution from scratch
Know how to handle padding (same vs. valid), stride, and the distinction between true convolution (kernel flip) and cross-correlation (no flip). PyTorch and TensorFlow implement cross-correlation and call it convolution—an interviewer might ask you to clarify this.
Describing a data augmentation pipeline
For a satellite imagery classification task: random horizontal and vertical flips, arbitrary rotation, color jitter, random crops. For medical imaging: skip aggressive color jitter (it changes diagnostic signal), prefer elastic deformations and careful intensity normalization. The key is justifying your choices by the domain, not listing every augmentation that exists.
System Design for Computer Vision Roles
System design rounds test whether you can build a real pipeline under real constraints. The answer isn't a specific model—it's a structured reasoning process.
"Design a real-time object detection system for a warehouse"
Walk through: input (camera specs, frame rate), preprocessing (resize, normalize, consider FPGA offload), model selection (MobileNet-SSD or YOLOv8 depending on latency requirements), deployment target (edge device vs. on-premise server), post-processing (NMS plus multi-object tracking if you need continuity across frames), and monitoring (detecting data drift when warehouse lighting changes between shifts). Interviewers care whether you reason through the full stack, not whether you name the right architecture.
"Design a face recognition pipeline at scale"
Components: face detection, alignment, embedding generation, similarity search (FAISS or similar approximate nearest neighbor—not brute force at scale), decision threshold. Critical discussion points: how you tune the false accept/reject tradeoff by application (phone unlock vs. access control), how you update the database without retraining the embedding model, and how you detect when distribution drift is causing accuracy to degrade.
Top Courses to Prepare for Computer Vision Interviews
These courses address the gaps most candidates have when they enter the interview loop.
Introduction to Computer Vision Course
Built on OpenCV with downloadable code notebooks, this Coursera course (rated 9.7/10) covers the core techniques that show up in CV interview questions: edge detection, image filtering, feature extraction, and object recognition. It's structured around implementations, not just theory, which is exactly what the coding round tests.
Mathematical Thinking in Computer Science Course
Computer vision interviews lean heavily on linear algebra (matrix operations, eigendecomposition for PCA), probability (Bayesian reasoning for detection thresholds), and discrete math. This course (rated 9.7/10) builds the mathematical foundation that lets you derive answers rather than memorize them—which interviewers can immediately tell the difference between.
Build a Modern Computer from First Principles
Understanding how hardware executes operations matters when you're reasoning about inference latency, memory bandwidth bottlenecks, and GPU parallelism in system design rounds. This project-centered Coursera course (rated 9/10) is unconventional preparation, but it gives you a mental model of computation that makes system design answers more credible and specific.
FAQ
What level of math do computer vision interviews require?
Linear algebra and probability are the most tested areas. You should be comfortable with matrix multiplication, dot products, eigenvalues (for PCA), and basic probability (Bayes' theorem, distributions). Calculus comes up when explaining backpropagation, but you usually don't need to derive anything from scratch—understanding what's happening conceptually is sufficient for most engineering roles. Research roles expect more depth.
Do I need to know classical computer vision or just deep learning?
Both. Classical techniques—Canny edge detection, SIFT features, Hough transforms, histogram equalization—still appear in interviews, especially at companies working in industrial or embedded contexts. More importantly, interviewers use classical CV questions to test your understanding of spatial reasoning and image formation. Knowing only PyTorch is a visible gap.
How much coding should I practice before a computer vision interview?
At minimum: implement IoU, NMS, 2D convolution, and basic image transforms (resize, crop, normalize) without looking anything up. Beyond that, practice at least 20–30 LeetCode problems in the medium/hard range—arrays, sliding window, dynamic programming. The algorithmic coding round is often identical to a standard software engineering interview; the CV-specific coding is additive on top of it.
What evaluation metrics do I need to know?
Mean average precision (mAP) for object detection, Intersection over Union for segmentation and detection, precision-recall curves, F1 score, and confusion matrices. Know when to use accuracy vs. F1 (class imbalance changes the answer). For segmentation specifically: Dice coefficient and pixel accuracy. If you're interviewing for a role with a real-time component, also know how to measure and report latency (P50, P95, not just average).
Should I read research papers to prepare?
Selectively. For engineering roles, you need to understand the key ideas in landmark papers (AlexNet, ResNet, YOLO, U-Net, DETR) without necessarily knowing the implementation details or ablation studies. For research roles, expect to discuss recent papers in depth, defend design choices, and reason about what the results do and don't prove. Check the company's recent publications—they often ask about their own work.
How long should I spend preparing for a computer vision interview loop?
If you have solid Python and some ML background but limited CV-specific knowledge: focus first on conceptual foundations (two to three weeks of consistent study), then shift to implementation practice, then do at least two or three mock system design sessions. Spreading preparation across all areas matters more than going very deep on any single one.
Bottom Line
The candidates who pass computer vision interview loops aren't always the ones who know the most—they're the ones who can explain what they know clearly, reason through unfamiliar problems systematically, and implement under pressure. Knowing the difference between semantic and instance segmentation matters; being able to describe it concisely while drawing a diagram matters more.
Start with the conceptual foundations, get comfortable implementing core algorithms without reference material, and practice system design by talking through your reasoning out loud. The Introduction to Computer Vision Course is the most direct way to build hands-on fluency if you're starting from a general ML background. Combine that with deliberate practice on the coding questions above and you'll be prepared for what most CV interview loops actually test.