From rules to a shopping list

The first article in this path set out what the doorstep greeter should do and the rules it has to follow: a visible sign that a camera is in use, no storing of anyone's face without their agreement, a limit on how long anything is kept, and a hard rule that a match against a flagged visitor only ever sends you a notification, never triggers an automatic action. Those decisions were made before a single wire was connected, because they shape the hardware as much as the software. A camera that must not sweep across the neighbour's front door needs a narrower lens and careful mounting. A system that must delete footage automatically needs storage that can be managed sensibly. A system that greets instead of just recording needs a speaker.

This article turns that plan into a physical parts list: a small computer to act as the brain, an optional chip to speed up the face recognition maths, a camera that can see in the dark as well as daylight, a speaker for the greeting, a motion sensor to wake the system up, enough power and storage to keep it reliable, and a box to keep the rain out. For each part we will explain what it actually does, why this project needs that particular kind of component rather than a cheaper or simpler one, and where people commonly get it wrong. Prices are given as rough, current-at-time-of-writing figures in US dollars; they move around with exchange rates, supply and new product revisions, so treat every number here as a ballpark for planning a budget, not a quote.

The brain: Raspberry Pi 5

A Raspberry Pi is a complete, small computer on a single circuit board: it has a processor, memory, USB ports, network connections and pins for attaching sensors, and it runs a full Linux operating system. The Raspberry Pi 5, released in 2023, is built around Broadcom's BCM2712 chip, which has four processor cores (Cortex-A76 cores, the same general family used in many phones) running at up to roughly 2.4 GHz. That is a meaningful step up from the Raspberry Pi 4's cores, which matters here because this project does not do one thing at a time: it needs to keep reading frames from the camera, run a face detector on those frames, compute a face embedding when a face is found, look that embedding up in a local database, speak a greeting through text-to-speech, log the visit, and serve a small web dashboard, all while staying responsive. A faster, more capable CPU gives you headroom to do all of that without everything slowing to a crawl.

The Pi 5 is sold with different amounts of RAM (working memory); 4 GB and 8 GB were the original options, with other capacities appearing later as the lineup grew. This project uses the 8 GB board. The reason is not that any single piece of software here is enormous, but that several processes run at once and each one holds its own copy of libraries, image buffers and model weights in memory; 8 GB gives enough slack that the operating system does not have to start swapping memory out to the SD card, which would make everything, especially the camera pipeline, noticeably jerky. An 8 GB board costs roughly $80, a little more than the 4 GB version.

Two physical details matter for this build specifically. First, the Pi 5 has two camera connectors (unlike the Pi 4, which has one), using a newer, thinner ribbon cable standard; when you buy a Camera Module 3, check that you also have the correct cable, since older Pi camera cables are not a direct fit. Second, the Pi 5 introduced a PCIe connector on the underside of the board, exposed via a short ribbon cable, which is how accessories like the AI HAT+ described below attach and communicate at high speed, rather than through the slower GPIO pins used for simpler add-ons.

One thing that surprises first-time Pi 5 builders is how warm it runs under sustained load. Running a camera pipeline and a face recognition model continuously is exactly this kind of sustained load, so plan for active cooling from the start: either Raspberry Pi's own Active Cooler (a small fan and heatsink that clips onto the board) or a case that includes one. Skipping this to save a few dollars is one of the common mistakes we will return to later, because the Pi does not fail loudly when it overheats, it just quietly slows itself down, and you will only notice as a vague sluggishness in how quickly the greeter recognises people.

Giving it a boost: do you need an AI accelerator?

Face recognition, as the next article will explain in detail, works by running two neural networks over each frame: one that finds faces in the image, and one that turns each face into a list of numbers (an embedding) that can be compared against the embeddings of people you already know. Running neural networks means doing enormous numbers of small multiplications and additions, over and over, on grids of numbers. A general-purpose CPU, like the one inside the Pi 5, can do this, but it was designed to be good at many different kinds of task, not optimised for this one repetitive kind of arithmetic. The result is that running both networks on every frame, using the CPU alone, is usually slow enough that you only manage a handful of frames per second, which can mean a visible pause between someone arriving at the door and being greeted.

An AI accelerator is a separate chip built specifically to do that repetitive multiply-and-add arithmetic very quickly and with much less electrical power per calculation than a general CPU. Its speed is usually quoted in TOPS, trillions of operations per second, as a rough measure of how much of that arithmetic it can get through. Think of the Pi's CPU as the head chef, handling the camera, the database, the speech and the web page, and the accelerator as a sous chef who only chops vegetables, but does it extremely fast, freeing the head chef to run the rest of the kitchen. For this project, offloading the face detector and embedding model to an accelerator is what makes the greeting feel instant rather than laggy.

Option A: Raspberry Pi AI HAT+

The Raspberry Pi AI HAT+ is an official add-on board that sits on top of the Pi 5, physically stacking onto it, and connects through that PCIe ribbon cable mentioned earlier rather than the slower GPIO header. It is built around a Hailo accelerator chip and is sold in a couple of variants with different rated performance (commonly described as a lower-TOPS and a higher-TOPS version); the exact figures and naming have shifted a little since launch, so check the current product page rather than relying on a number printed in an older guide. Prices are roughly in the $70 to $130 range depending on the variant.

The appeal of this option for the project is that it keeps you entirely inside the Raspberry Pi ecosystem: the same Raspberry Pi OS, the same picamera2 library for the camera, the same Python version, the same apt package manager you will use throughout this path. You install an additional runtime for the Hailo chip and, where needed, convert or download a version of the face models that targets it, but the rest of the system (storage, dashboard, speech) stays exactly as described in later parts. The trade-off is that this is a newer product with a smaller library of ready-made, pre-converted models compared to the much larger ecosystem around NVIDIA's chips, so you may occasionally need to do a conversion step yourself, and its outright compute ceiling is lower than a dedicated Jetson board if you ever wanted to run several cameras or much larger models at once.

Option B: NVIDIA Jetson Orin Nano, as a different board altogether

It is worth being clear about what the Jetson Orin Nano actually is, because it is easy to assume it is an add-on like the AI HAT+. It is not. It is a complete, separate single-board computer that would replace the Raspberry Pi 5 entirely, with its own NVIDIA GPU (built on NVIDIA's Ampere architecture, with CUDA cores and tensor cores dedicated to this same multiply-and-add arithmetic) built into the same board as its CPU. It runs NVIDIA's own software stack, JetPack, which is based on Ubuntu Linux rather than Raspberry Pi OS, has a different set of camera interfaces and connectors, and a different GPIO pin layout.

The appeal is raw headroom: the Jetson family has a much larger and more mature deep learning software ecosystem (CUDA and TensorRT in particular are widely used and well documented), and if you later wanted to add more cameras, run heavier models, or do more at once, it has more room to grow into. The cost of that headroom is a higher price (developer kits for this class of board have generally sat somewhere in the low hundreds of dollars, though NVIDIA has adjusted pricing over time, so check current listings rather than trusting an older figure), higher power draw, a steeper setup for a Python learner since the operating system and driver stack are different, and, importantly for this series, a different set of exact commands. Every hands-on article from here on gives instructions for Raspberry Pi OS, Python 3.11 and picamera2; if you build on a Jetson Orin Nano instead, the ideas (detect a face, compute an embedding, compare it to known faces, speak a greeting) transfer directly, but you will need to adapt the specific installation and camera-access commands yourself, since this path does not cover JetPack setup step by step.

Can you skip the accelerator entirely?

Yes, and it is a reasonable budget choice. The Pi 5's CPU alone can run a lightweight face detector and a compact embedding model, just more slowly. For a doorbell, that slowness is often tolerable: a visitor standing at your door for several seconds while you decide whether to answer gives the system more time than, say, a security camera trying to catch someone walking past at speed. Later hands-on parts will note where code can run on the CPU alone versus where an accelerator speeds things up, so you are not locked into buying one before you have tried the simpler path.

The eyes: Camera Module 3, NoIR, and seeing in the dark

The Raspberry Pi Camera Module 3 is the official camera for the Pi, built around a 12-megapixel Sony sensor with autofocus, and it connects via the ribbon cable mentioned earlier to the Pi 5's camera connector. In Python, it is accessed through the picamera2 library, which the hands-on part 4 will install and use. It comes in a few variants, including a wide-angle lens option, and, importantly for this project, a NoIR version.

Ordinary cameras, including the standard Camera Module 3, include a small filter in front of the sensor called an IR-cut filter, which blocks infrared light. Human eyes cannot see infrared, so if a camera let it through, daylight photos would look slightly wrong, often with an unnatural reddish or pinkish tint, because the sensor is sensitive to wavelengths our eyes are not. The IR-cut filter is there specifically to make daytime colours look natural. The NoIR version of the camera, as the name suggests, has that filter removed. In daylight, this gives photos a mild colour cast, which does not matter much here because what the face detector and embedding model actually use is the pattern of light and shade across a face, not accurate colour. What the NoIR sensor gains in exchange is the ability to register infrared light at night, light that is completely invisible to a person standing at the door.

That last point is easy to miss: a NoIR camera on its own does not see in the dark any more than a normal camera does. All a camera can do is register light that is already there. At night, there usually is no infrared light reaching the doorstep for the sensor to pick up, any more than there is visible light. What makes a NoIR setup actually useful after dark is pairing it with an IR illuminator, a small board of infrared LEDs that floods the area in front of the door with infrared light, invisible to visitors but clearly visible to the NoIR sensor. Illuminators commonly come in two wavelengths: 850 nanometre LEDs, which give off a very faint, dim red glow that a careful observer might notice, and 940 nanometre LEDs, which are essentially invisible to people but usually have a shorter effective range and the sensor is often a little less sensitive to them. We will wire one up properly and compare the two in the later part on working at night, rain and glare; for now, the planning point is that the camera and the illuminator are two separate purchases, and a NoIR camera bought without an illuminator will leave you with a dark, empty frame after sunset.

One more thing worth deciding at the hardware stage, because it affects which lens and how you mount the camera, is field of view. A wide lens captures more of the scene, which sounds appealing, but part of the responsible design agreed in the previous article was to point the camera narrowly at your own doorstep rather than sweeping across a shared path, a neighbour's window, or the public pavement more than necessary. A narrower field of view, aimed down slightly at where a visitor's face will actually be, usually also helps face recognition directly, because the face occupies more of the frame and the detector has less background to search through. A NoIR Camera Module 3 costs roughly $35 to $50; a basic IR illuminator board adds roughly $10 to $25.

The voice: a small speaker

Part 7 of this path covers turning text into spoken greetings on the device, using an offline voice so that nothing about who visited needs to leave the Pi to generate speech. For that to be audible at a front door, you need a speaker connected to the Pi. There are two common ways to do this. The simplest is a small USB speaker: it plugs directly into a USB port, draws its own power from that port, and is recognised by Linux as an audio output with no extra wiring, which makes it the easiest starting point for a Python learner. The alternative is an I2S speaker, typically a small amplifier board paired with a small speaker driver, wired directly to a handful of the Pi's GPIO pins; it is more compact and does not use up a USB port, but it needs a short bit of wiring and a small amount of configuration to tell Raspberry Pi OS that audio should be routed through those pins rather than the default output.

For getting started, a simple USB speaker is the easier and cheaper choice, roughly $10 to $20, and is what the early hands-on parts will assume; part 7 will mention the I2S option as an alternative for anyone comfortable with a little extra wiring. Whichever you choose, keep the eventual volume modest. A greeting is meant to be a friendly, conversational notice that the system recognises you, not a public announcement; a quieter, close-range speaker is both more pleasant for visitors and more considerate of neighbours, which fits the same proportionality principle from part 1 that shaped the camera's field of view.

The trigger: a PIR motion sensor

It would be technically possible to leave the camera running and analysing every frame, all the time, waiting for a face to appear. This project deliberately avoids that, for a reason that goes beyond saving power: a system that is constantly processing footage of the street, even when nobody is there, has a larger surveillance footprint than one that only wakes up when something approaches. A passive infrared, or PIR, motion sensor gives a simple, low-cost way to do that waking up without the camera needing to be the thing doing the watching.

A PIR sensor is a small, cheap device, the common HC-SR501 module being a typical example at roughly $2 to $6, that detects a change in infrared radiation across the area it faces, which is what happens when a warm body moves through its field of view. It does no image processing at all, it simply flips an output pin from low to high (or back) when it detects that kind of change, and the Pi's software, covered in a later hands-on part, listens for that signal on a GPIO pin and uses it as the cue to turn the camera pipeline on. Most of these modules have two small adjustable dials: one for sensitivity, and one for how long the output stays high after it triggers, both of which you will tune once the sensor is mounted in its real spot, since a test on a desk indoors behaves differently from a doorway in direct sun.

PIR sensors are not perfectly reliable triggers on their own. Cheap modules are prone to false triggers as the sun warms the sensor casing at dawn or dusk, from foliage moving in the wind, or from vehicles and pedestrians passing on a street within its field of view if it is not angled carefully. The later part on working outdoors covers tuning and placement in practice. For planning purposes, the useful mental model is that the PIR sensor only answers the question

Did something move nearby?

and the camera and face detector, running afterwards, answer the separate and more specific question of whether what moved is actually a person's face worth recognising.

Keeping it running: power supply and storage

The Raspberry Pi 5 draws noticeably more current than earlier Pi models, and Raspberry Pi's own guidance is to use a USB-C power delivery supply rated at 5 volts and 5 amps, 27 watts, especially once you attach accessories like a camera, a HAT and a speaker, all of which add to the total draw. Using an old phone charger or a cheap, underrated supply is one of the most common sources of mysterious Raspberry Pi problems: under-voltage warnings, random reboots under load, or silent throttling that looks exactly like the overheating problem described earlier but is actually the board protecting itself from a sagging power supply. An official or clearly specified 27-watt USB-C supply costs roughly $12 to $15 and removes this entire category of problem.

If the enclosure will be mounted some distance from an indoor socket, you will also need to think about how power physically reaches it: either a weatherproof-rated extension run of cable, or, for people comfortable with slightly more setup, a Power-over-Ethernet HAT, which carries both power and a network connection over a single Ethernet cable. That option adds cost and a little complexity and is mentioned here only so you know it exists; this path assumes a straightforward mains power run.

For storage, the Pi 5 boots from a microSD card, which will hold the operating system, the Python environment, the face detection and embedding models, the SQLite database of people the system knows, logs, and any visitor photos awaiting deletion under the retention rules from part 1. Buy at least 32 GB, and realistically 64 GB gives more comfortable headroom. Look specifically for cards rated A2 (Application Performance Class 2), a rating that describes how well a card handles many small random reads and writes, rather than just its large-file transfer speed. This matters here because a running database that logs each visit, plus application logs, is exactly the kind of workload, lots of small writes, that cheap, large-capacity cards tend to be worst at and wear out fastest under. A 64 GB A2 card costs roughly $10 to $15, only a little more than a lower-rated card of the same size, and will hold up noticeably better under this project's particular pattern of use. The later part on retention and auto-deletion also helps here, simply by reducing how much gets written and kept in the first place.

Weatherproofing: the outdoor enclosure

None of the parts described so far, the Pi board, an accelerator HAT, the camera, the speaker or the PIR sensor, are designed to survive rain, direct sun, dust or insects, so an outdoor enclosure is not optional once the project leaves your desk for the doorstep. Enclosures are commonly described using an IP rating, two digits that describe how well sealed a product is: the first digit, from 0 to 6, describes protection against solid objects and dust, and the second, from 0 to roughly 9, describes protection against liquids. For a doorstep camera exposed to driving rain, look for something rated at least IP65, meaning dust-tight and protected against water jets from any direction; if the mounting spot is well sheltered under a deep porch roof, a lower rating such as IP54 may be enough, but check this against your own local weather rather than assuming shelter is adequate.

Beyond the headline rating, a few practical details separate a good enclosure from a frustrating one. The front window, the clear panel the camera lens looks through, should be a stable material such as polycarbonate or glass; cheap acrylic can yellow and cloud with UV exposure over a year or two, quietly degrading image quality in a way that is easy to miss until it is bad. Some ventilation, ideally a small gap behind a dust-resistant membrane rather than a fully sealed box, helps with two separate problems: heat build-up, since a sealed black box left in direct sun can get hot enough to push a CPU or accelerator into thermal throttling even with internal cooling, and condensation, which forms when a cold night is followed by a sudden temperature swing and can fog the inside of the window. A small desiccant sachet, the kind found in shoe boxes, placed inside the enclosure is a cheap way to reduce condensation. Cable entry points should use proper cable glands, grommets with a rubber seal around the cable, so that rain running down the power cable cannot track its way inside the box. Finally, you need a solid mounting bracket that lets you angle the camera down slightly at face height, which, as mentioned earlier, both improves how well faces fill the frame and keeps the camera's view narrow and proportionate rather than sweeping across more of the street than it needs to.

You can buy a purpose-built weatherproof enclosure designed for a Pi and camera from hobbyist electronics retailers, or adapt a general-purpose electrical junction box with a hole cut for the lens; either is workable as long as it meets the rating you need and leaves you a way to access the SD card and a reset button without fully dismantling it. Prices vary a great deal depending on size and build quality, roughly $20 to $60 for a dedicated hobbyist case, more for a professional outdoor camera housing.

Putting it together: an approximate shopping list

The list below assumes the Raspberry Pi 5 with AI HAT+ path, since that is the one the hands-on parts of this series will walk through step by step. Every figure is an approximate, current snapshot, not a quote, and will drift with time, region and retailer.

  • Raspberry Pi 5, 8 GB — roughly $80
  • Raspberry Pi AI HAT+ (Hailo-based, 13 or 26 TOPS variant) — roughly $70 to $130, or an NVIDIA Jetson Orin Nano Developer Kit instead of the Pi 5 and HAT entirely — roughly a few hundred dollars, check current pricing as it has changed since launch
  • Camera Module 3, NoIR variant — roughly $35 to $50
  • Infrared illuminator board — roughly $10 to $25
  • Small USB speaker — roughly $10 to $20
  • PIR motion sensor (such as an HC-SR501 module) — roughly $2 to $6
  • Official or equivalent 27 W USB-C power supply for the Pi 5 — roughly $12 to $15
  • 64 GB A2-rated microSD card — roughly $10 to $15
  • Active cooler or cooling case for the Pi 5 — roughly $5 to $15
  • Outdoor enclosure with cable glands and a clear window — roughly $20 to $60
  • Mounting bracket, cables and miscellaneous fixings — roughly $10 to $20

Added up, the Raspberry Pi 5 with AI HAT+ path comes to roughly $250 to $350 depending on which variants and enclosure you pick. The Jetson Orin Nano alternative tends to land higher overall, mainly because of the board itself, and it replaces the Pi 5 and AI HAT+ lines above rather than adding to them. Buying from official or well-established resellers is worth the small premium it sometimes costs, since it gives you a warranty and a clearer path to support if a board arrives faulty.

Common mistakes to avoid

  • Underpowering the board. A cheap or recycled phone charger often cannot supply the current a Pi 5 with accessories needs, leading to under-voltage warnings, random reboots, or silent throttling that looks like a software bug but is not.
  • Buying the standard Camera Module 3 by mistake. The listing should say NoIR explicitly; a standard sensor's IR-cut filter will leave you with nothing but darkness at night no matter how good the illuminator is.
  • Forgetting the IR illuminator. A NoIR sensor only helps if there is infrared light for it to register; without an illuminator it is about as blind in the dark as any other camera.
  • Skipping active cooling to save a little money. The Pi 5 runs hot under sustained face recognition workloads, and thermal throttling does not announce itself, it just quietly slows everything down.
  • Choosing an SD card by capacity alone. A large but low-endurance card can wear out faster under this project's pattern of frequent small database writes than a smaller card rated A2 for random read and write performance.
  • Sealing the enclosure completely with no thought for heat or condensation. This leads to overheating in strong sun and fogged lenses after cold nights, both avoidable with basic ventilation and a desiccant sachet.
  • Mounting the camera to capture as wide a view as possible. A narrower field of view aimed at your own doorstep, as agreed in part 1, is both more considerate of neighbours and the public pavement, and generally better for recognition, since faces fill more of the frame.
  • Mixing up ecosystems without realising it. If you choose the Jetson Orin Nano as an alternative to the Pi 5 and AI HAT+, remember that it runs a different operating system and camera stack; the ideas in this path transfer, but the exact commands in later hands-on parts, written for Raspberry Pi OS and picamera2, will need adapting.
  • Expecting the PIR sensor to work perfectly straight out of the box. Outdoor light, passing traffic and foliage all affect it differently from an indoor test; plan to tune its sensitivity and delay once it is mounted in its real spot, which the part on working outdoors covers in detail.

Summary and what's next

This article turned the plan from part 1 into a concrete parts list: a Raspberry Pi 5 with 8 GB of memory as the brain, with an optional AI HAT+ or, as a separate alternative board entirely, an NVIDIA Jetson Orin Nano, to speed up the face recognition maths; a NoIR Camera Module 3 paired with an infrared illuminator so the system can see by day and by night; a small speaker for the spoken greeting covered later; a PIR motion sensor that wakes the system up only when something approaches, in keeping with the privacy-minded design from part 1; a properly rated power supply and a durable microSD card to keep the whole thing reliable; and a weatherproof enclosure, chosen with an IP rating appropriate to how exposed the doorstep actually is, to let all of it survive outdoors. Along the way we touched on several decisions, like field of view and mounting angle, that are really extensions of the ethical and legal groundwork laid in the first article, not separate concerns from it.

With the hardware chosen, the next article steps back from physical parts and explains how face recognition itself actually works: how a face is detected in an image, how it is aligned, how it is turned into the numeric embedding mentioned several times in this article, and how that embedding is matched against the people you already know. Understanding that process will make the hands-on setup in part 4, where you will actually assemble the Pi, the camera and the Python environment, much easier to follow, because you will know what each piece of software is for before you install it.