How a Camera Sensor Works

June 19, 2026 17 min read Photography & Imaging Engineering

photographysensorsimagingcmosbayersilicon

Contents

A camera sensor is a photon-counting machine glued to a clock. Light arrives, electrons accumulate, a circuit measures the accumulation, an analog-to-digital converter turns the measurement into a number, and a 2D array of those numbers becomes the image. Everything photographers argue about — full-frame versus phone, low-light performance, dynamic range, that intangible “look” of a particular body — reduces to how well that pipeline runs and how big each pixel is. The physics is brutally simple and brutally unforgiving: photons either land on your silicon or they do not, and electrons either get counted accurately or get drowned in noise. A 1.4-micron phone pixel and a 6-micron full-frame pixel are not different in kind; they differ in area, and area is destiny when your signal is a Poisson process. This post walks the modern CMOS imaging pipeline end to end — photoelectric conversion, the Bayer color filter array, front-side versus back-side illumination versus stacked architectures, column-parallel ADCs, the read-noise floor, full-well capacity, and the resulting dynamic range — then explains, with real numbers from Sony, Nikon, Canon, Fuji, and Phase One sensors, why the same scene produces wildly different files on different chips, and where computational photography genuinely closes the gap and where it cannot.

From photon to electron

The photoelectric effect — the one Einstein got his Nobel for — is the entire foundation. A photon with enough energy hits a silicon atom, kicks an electron into the conduction band, and that electron becomes part of a measurable signal. Silicon’s bandgap is about 1.12 eV, comfortably below the energy of every visible-light photon (roughly 1.7 to 3.1 eV), so every visible photon that reaches the silicon has the potential to free an electron. The catch is “potential.” Quantum efficiency (QE) measures the fraction that actually produce a counted electron, and modern back-illuminated CMOS sensors hit 50 to 65 percent QE in the green channel at peak wavelength. The rest reflect off the surface, get absorbed in the wrong layer, or recombine before collection. A theoretical 100 percent QE is the wall; nothing on the market is closer than about two-thirds of the way there.

Each pixel is a pinned photodiode plus a small cluster of transistors that handle reset, transfer, source-follower amplification, and row-select. The photodiode is a reverse-biased junction acting as a capacitor for photoelectrons: as electrons accumulate, the junction voltage changes in proportion. Readout samples that voltage twice — once at reset (the kTC noise reference) and once with the accumulated signal — and the difference is the photon-derived signal. This is correlated double sampling (CDS), and it is the single most important reason modern read noise is in the low single-digit electrons instead of dozens.

The maximum number of electrons a pixel can hold before saturating is the full-well capacity (FWC). FWC scales roughly with pixel area; a 1.4-micron phone pixel holds 6,000 to 10,000 electrons, while a 6-micron full-frame pixel sits comfortably above 60,000 to 80,000. Saturation is a hard clip — highlights blow to pure white once the well is full. FWC sets the top of the dynamic range; read noise sets the bottom. The ratio, in base-2 log, is the engineering dynamic range. Roughly 80,000 / 1.5 electrons is 53,000:1, or 15.7 stops — exactly the neighborhood the best modern full-frame sensors live in.

The Bayer color filter array

A silicon photodiode is colorblind. It counts photons but cannot tell you whether they were red, green, or blue. To recover color, almost every consumer camera sensor places a color filter array (CFA) directly on top of the pixels, so each pixel sees only one of the three primary colors. Bryce Bayer’s 1976 Kodak patent introduced the pattern that has dominated digital imaging for fifty years: a repeating 2x2 tile of one red, two green, and one blue filter.

+----+----+----+----+----+----+
| R  | G  | R  | G  | R  | G  |
+----+----+----+----+----+----+
| G  | B  | G  | B  | G  | B  |
+----+----+----+----+----+----+
| R  | G  | R  | G  | R  | G  |
+----+----+----+----+----+----+
| G  | B  | G  | B  | G  | B  |
+----+----+----+----+----+----+
       Bayer RGGB CFA
       (2 greens per 2x2 tile)

The two-green choice is not arbitrary. Human luminance perception is dominated by the green channel — the medium-wavelength cones sit close to green — so doubling the green sample density gives the most perceptually relevant detail per unit silicon. The cost is that every pixel records only one third of the color information; the other two channels are reconstructed by demosaicing, interpolating from neighbors. Modern algorithms like AHD, DCB, and the neural demosaicers in current raw converters use directional gradient analysis to avoid the classic zipper artifacts and color fringing on high-frequency edges.

There are alternatives. Fujifilm’s X-Trans CFA uses a 6x6 pattern with a more randomized R/G/B distribution, scattering the color grid’s spatial frequency and reducing moire enough that Fuji can omit the optical low-pass filter on X-Trans bodies like the X-H2 and X-T5. Sigma’s Foveon sensors took a different route: three stacked photodiodes per pixel location, exploiting silicon’s wavelength-dependent absorption depth (blue near the surface, red deeper) to capture full color without a CFA. Foveon is theoretically elegant, but the deep diodes have worse QE and higher noise, and Sigma has struggled to bring a full-frame Foveon to market for the better part of a decade.

FSI, BSI, and stacked CMOS

Once you have a photodiode and a CFA, you still have to wire everything up. The wiring is the entire story of the last fifteen years of sensor architecture.

Front-side illuminated (FSI), traditional CMOS:

  light  light  light
   |      |      |
   v      v      v
  [microlens layer]
  [color filter ]
  [metal wiring -- blocks light!]
  [metal wiring -- blocks light!]
  [    photodiode (silicon)    ]
  [        substrate           ]

Back-side illuminated (BSI), modern:

  light  light  light
   |      |      |
   v      v      v
  [microlens layer]
  [color filter ]
  [    photodiode (silicon)    ]   <-- thinned, flipped
  [metal wiring (below)        ]
  [metal wiring (below)        ]
  [        carrier wafer       ]

Stacked BSI CMOS:

  light  light  light
   |      |      |
   v      v      v
  [microlens / CFA]
  [    photodiode wafer        ]
  [TSV][TSV][TSV][TSV][TSV][TSV]  <-- through-silicon vias
  [logic wafer: ADCs, memory,  ]
  [ image signal processing    ]

In a front-side illuminated (FSI) sensor, the silicon is fabricated normally: photodiodes at the bottom, metal interconnect on top. Light has to thread past the wiring to reach the photodiode, and a substantial fraction is blocked. FSI sensors typically hit QE in the 30 to 40 percent range and have ugly per-pixel angular response.

Back-side illuminated (BSI) sensors flip the problem. After fabrication, the wafer is thinned, bonded to a carrier, and flipped so light enters from the back of the silicon directly into the photodiode with no metal in the way. QE jumps to 50 to 65 percent, angular response improves, and crosstalk falls. BSI was a luxury a decade ago; today every meaningful sensor in a phone or interchangeable-lens camera is BSI.

Stacked CMOS goes one step further. The photodiode wafer and a separate logic wafer (ADCs, memory, sometimes DRAM, sometimes an ISP) are bonded face-to-face and connected with through-silicon vias (TSVs) or hybrid bonding. This frees pixel area from sharing real estate with readout transistors, lets the logic be fabricated on its own optimized node, and allows massive parallelism. The Sony IMX989 in the Xiaomi 13 Ultra, Vivo X90 Pro+, and OPPO Find X6 Pro is a stacked 1-inch (Type 1/0.98, 16.384 mm diagonal) 50 MP sensor with a 1.6-micron native pixel pitch, leaning on the stacked architecture for per-pixel HDR and on-sensor binning. The Nikon Z9, Sony A1 II, and Sony A9 III use stacked sensors at the other end of the price spectrum: stacked logic reads the entire frame in a few milliseconds, eliminating rolling-shutter distortion and enabling true electronic global shutter on the A9 III.

Column-parallel ADCs and the read-noise budget

A modern sensor cannot read pixels one at a time. A 45 MP sensor read serially at any reasonable bit depth would take seconds per frame. The standard architecture is one ADC per column, sometimes split into upper and lower halves, occasionally (in the most aggressive stacked designs) one ADC per pixel. The Sony A1, Nikon Z9, and Canon R5 Mark II use column-parallel ramp ADCs at 12 or 14 bits; the Phase One IQ4 150 MP and Fujifilm GFX100 II run 16-bit ADCs. A 14-bit ADC over a 60,000-electron well gives roughly 3.6 electrons per code — you do not want the quantization step much larger than your read noise, or you give back the noise floor advantage at the digitizer.

The very best modern full-frame sensors hit read noise of about 1.0 to 1.5 electrons at base ISO with dual-gain readout enabled. Ten years ago, the same number was 4 to 7 electrons. The improvement comes from CDS refinements, lower-noise source-follower transistors, careful clock and power-supply layout in the column ADC, and on-sensor digital averaging.

Dual conversion gain is the other big recent move. A pixel is read at two different conversion gains — one for low signal (high gain, low read noise, lower effective full well) and one for bright signal (low gain, higher read noise in electrons but enormous full-well swing). The sensor or camera decides which to use per pixel or per row. The Sony A7R V, A7 IV, Nikon Z9, and Canon R5 Mark II all employ dual-gain readouts to extend dynamic range past 14 stops at base ISO. The A7R V measures around 15 stops at ISO 100; the Z9 sits near 14.4 stops at ISO 64; the Phase One IQ4 150 MP can exceed 15 stops at base ISO 50. These correspond directly to FWC divided by read noise in base-2 log.

Pixel size, sensor size, and why files differ so much

The single most important number on a sensor’s spec sheet is not megapixel count. It is pixel pitch, and behind that, total sensor area. Photon arrival is a Poisson process, which means the noise on a signal of N photons is sqrt(N). Signal-to-noise ratio scales with sqrt(N), and N scales linearly with pixel area for a given scene illuminance. Doubling pixel area gives you one stop of shot-noise SNR for free. There is no algorithm that gets around this; it is a property of how photons behave.

Sensor	Diagonal	Area (mm^2)	Typical pixel pitch	Typical FWC	Read noise (base)	Engineering DR
1/2.55-inch phone (e.g. iPhone)	~7.0 mm	~24	1.4 microns	~6,000 e-	~2.0 e-	~11.5 stops
1/1.28-inch (Sony IMX800-class)	~12.5 mm	~75	1.6 microns (binned)	~10,000 e-	~1.8 e-	~12.5 stops
1-inch (Sony IMX989, phone)	16.384 mm	~116	1.6 microns	~10,000 e-	~1.6 e-	~12.7 stops
Four Thirds (OM-1 II)	~21.6 mm	~225	3.3 microns	~26,000 e-	~1.5 e-	~13.5 stops
APS-C (Fujifilm X-H2 / X-T5)	~28.3 mm	~370	3.0 microns	~28,000 e-	~1.4 e-	~14.0 stops
Full-frame (Sony A7R V)	43.3 mm	864	3.76 microns	~46,000 e-	~1.2 e-	~15.0 stops
Full-frame (Nikon Z9)	43.3 mm	864	4.35 microns	~52,000 e-	~1.5 e-	~14.4 stops
Full-frame (Sony A7 IV)	43.3 mm	864	5.1 microns	~70,000 e-	~1.4 e-	~14.7 stops
Fujifilm GFX100 II (44x33)	55 mm	~1452	3.76 microns	~50,000 e-	~1.2 e-	~15.3 stops
Phase One IQ4 150 MP (53.4x40)	67 mm	~2135	3.76 microns	~52,000 e-	~1.0 e-	~15.6 stops

These numbers are nominal; manufacturers do not always publish FWC, and read noise varies with ISO and gain mode. But the structure is honest: each step up the size ladder buys roughly half a stop to a stop of dynamic range. A full-frame sensor has 36 times the area of a typical phone sensor — 5.2 stops of total light gathering before you even talk about per-pixel quality.

The reason a phone and a full-frame produce different files from the same scene is not that the phone has a worse sensor in any engineering sense; Sony’s mobile sensors are genuinely state-of-the-art silicon. It is that the phone is collecting roughly 1/36th of the light. Computational photography compensates by stacking many exposures (Apple’s Smart HDR, Google’s HDR+, the Pixel Night Sight pipeline), denoising with learned priors, and aligning frames with sub-pixel precision before averaging. A modern phone in good light can produce files that rival a full-frame at base ISO. In low light, the gap reopens because the phone is still gathering 1/36th of the photons and no algorithm can invent the missing ones; it can only smooth and guess.

ISO, gain, and the dual-gain trick

Base ISO is the sensitivity at which the sensor’s full well matches the maximum signal the analog chain expects. For most modern bodies this is ISO 100; for the Nikon Z9 it is ISO 64; for many cinema bodies it is ISO 800. Above base ISO, the sensor is not actually more sensitive — the photodiodes have the same QE — it is amplifying the signal before the ADC. ISO 800 on a full-frame sensor is just ISO 100 with the readout chain gained up by three stops, and the highlight headroom is three stops lower.

ISO below base is almost always a software trick: the camera exposes for ISO 100 and attenuates in software, costing a stop of dynamic range at the top because highlights still clip at the same physical full well. Exceptions are sensors with genuine dual-base ISOs (Panasonic GH5S, GH6, Canon C300 Mark III), where the readout chain truly has two gain modes. Dual-gain readout in stills bodies generalizes this: the sensor reads every pixel at both gains and the camera merges them, giving you the dynamic range of the low gain and the read noise of the high gain in one exposure.

Microlenses, phase-detect AF pixels, and on-sensor HDR

Above the color filter sits a microlens array, one refractive element per pixel, focusing light from the wide cone exiting the rear lens element onto the small active area of the photodiode. Microlens design has to work for the full angular range of incoming light, which differs across the sensor — the edges see light at a steeper angle than the center — so modern designs use shifted microlenses near the edges, aspheric on the highest-pixel-density chips.

Embedded in the array on most modern mirrorless sensors are phase-detection autofocus pixels: pixels with asymmetric masks that respond to light from only one side of the lens aperture. Comparing the signal from a left-masked and right-masked pair gives disparity for an out-of-focus image, and the camera computes how far the lens needs to move. The Sony A7R V has roughly 700 PDAF points across the frame; the Canon R5 Mark II uses Dual Pixel CMOS AF II, where every pixel is split into two photodiodes that read independently for AF and sum for imaging, so the entire sensor is the AF system. Conventional PDAF pixels are dimmer in the final image and get interpolated like dead pixels; Dual Pixel avoids that but doubles readout complexity.

On-sensor HDR comes in two flavors: multi-exposure stacking inside one readout cycle (what the stacked IMX989 does in its sensor-HDR mode), or per-row alternating ISO, where odd and even rows are read at different gains and the image is reconstructed by a deinterlacing-like algorithm. Both trade vertical resolution or temporal coherence for dynamic range.

The silicon underneath

A modern image sensor is not a generic CMOS chip. Sony Semiconductor, Samsung S.LSI, and OmniVision all run image sensors on dedicated processes — typically 45 to 65 nm for the pixel wafer (optimized for low dark current and good QE rather than transistor density) and a more modern node (28 or 22 nm) for the stacked logic wafer. The pixel process uses low-defect epitaxial silicon, deep trench isolation between pixels to suppress crosstalk, and carefully engineered junction profiles to maximize the depletion region without raising dark current. The same physical foundations that make a logic transistor a switch make a photodiode a low-noise photon counter, but the optimization targets are nearly opposite: logic wants speed and density and accepts leakage; pixels want pristine charge integration and accept slower transistors.

Stacked sensors exploit this divergence by fabbing the two halves separately on the right nodes and bonding them. Hybrid bonding now achieves bond-pitch geometries below 2 microns, dense enough to connect every column or even every pixel to dedicated logic underneath. The process belongs to the same family of advanced packaging that drives modern HBM and chiplet designs, and it is one reason sensor process technology and the broader silicon manufacturing world are no longer cleanly separable. The pipeline from photodiode to raw file is increasingly a packaging problem as much as a silicon problem, much like the DRAM data path has become a bandwidth problem more than a cell problem.

What the file actually looks like

After demosaicing, white-balance correction, color matrix transformation, tone mapping, and gamma encoding, the per-pixel electron count becomes a JPEG pixel value. Raw files preserve the per-pixel ADC count plus calibration metadata and let you run the entire downstream pipeline in software. A 14-bit raw is roughly 16,000 levels per pixel per channel; the human eye can distinguish maybe 200 to 300 luminance levels in a single viewing condition, so the extra bits are headroom for editing — shadow pulls, highlight recovery, color rebalancing — without banding. This is why raw editing on a phone is less dramatic than on a full-frame: the underlying SNR is lower, so shadow pulls reveal noise quickly. The display you edit on matters too, and the trade-offs between OLED, IPS, and VA monitor panels bound how much of the file you can actually see.

The honest summary is that sensor engineering has been improving slowly in the per-pixel domain — read noise drops a fraction of an electron per generation, QE creeps up a few percent — and quickly in the system domain. Stacked logic, on-sensor HDR, dual-gain readout, embedded PDAF, and computational pipelines spanning sensor and ISP are where the gains have been. The fundamental limits — photon shot noise, FWC scaling with area, silicon’s bandgap — have not moved.

Verdict

A sensor is a counter. It counts photons through a colored filter, with imperfect quantum efficiency, and turns the count into a digital number with small but nonzero read noise. Every meaningful difference between a phone and a full-frame body traces back to this counting, mostly through pixel area and total sensor area. Pick a phone for convenience and the computational pipeline; pick a larger sensor when the physics of photon collection matters — low light, deep editing, shallow depth of field on demand, files that can be pushed hard. Inside a given sensor size, the modern best-in-class options (Sony A7R V, Nikon Z9, Canon R5 Mark II, Fuji GFX100 II, Phase One IQ4) differ less than the marketing implies; they sit within about a stop of each other on engineering dynamic range, and the differences in final files come more from color science, lens choice, and post-processing than from the silicon. The phone sensors at the top of the market — Sony IMX989, IMX758, the latest Samsung ISOCELL HP variants — are genuinely impressive pieces of silicon, but they are competing against an area disadvantage of one to two orders of magnitude. Computational photography closes part of that gap and will continue to. It will not close the photon-counting part, because nothing can.