What Is a Breadboard and How to Use One for Your First Circuit

Building your first solderless breadboard circuit without soldering

You can write a binary search in your sleep, but someone hands you a resistor and you freeze. Which way does it go? Does direction even matter? (For a resistor, no. For an LED, very yes.) That gap between writing software and making something physical happen has a name, and the tool that closes it costs about $5.

A breadboard is the REPL of hardware. You wire something up, try it, pull it apart, try again. No solder, no commitment, no smoke (usually). By the end of this tutorial you’ll have an LED that lights up when you press a button, controlled by 6 lines of MicroPython running on a Pi Pico. The wiring takes 5 minutes. The code takes 2.

What Is a Breadboard?

A solderless breadboard is a plastic grid full of holes, with metal clips underneath that connect those holes in predictable patterns. Push a component leg into a hole, and it’s electrically joined to every other hole in the same group. Pull it out, and the connection’s gone. Prototyping without permanence.

Most starter kits ship a half-size board (about 400 holes), which is plenty for a first circuit. Full-size boards (830 holes) give you more room for chips that need to straddle the middle.

Here’s the anatomy:

   +  -                                          +  -
   │  │   a b c d e         f g h i j            │  │
 ┌─●──●───●─●─●─●─●─────────●─●─●─●─●────────────●──●─┐
 │ │  │   └─┴─┴─┴─┘ row 1   └─┴─┴─┴─┘            │  │ │
 │ │  │   └─┴─┴─┴─┘ row 2   └─┴─┴─┴─┘            │  │ │
 │ ●  ●        ...       (center gap)       ...  ●  ● │
 │ │  │                                           │  │ │
 └─●──●───────────────────────────────────────────●──●─┘
   power rails        terminal strips           power rails
   (vertical)         (horizontal, 5 holes)     (vertical)

Diagram: a half-size breadboard with two vertical power rails on each edge and horizontal terminal strips in the middle, split by a center gap.

How the Holes Connect (The Mental Model)

This is the one concept that unblocks everything: which holes are electrically the same node?

  • Power rails (the long columns marked + and -): every hole in the column is one node. Heads up, on some boards the rails split halfway down. If your circuit suddenly stops working when you move a wire 5cm, that’s why. Bridge the gap with a jumper.
  • Terminal strips (the rows in the middle): each row of 5 holes (a-e on the left, f-j on the right) is one node. Row 1 a-e is one node. Row 1 f-j is a different node.
  • Center gap: isolates the two halves so a DIP chip can sit across it without shorting its own pins.

Software analogy: think of each connected group as a single variable holding a wire. Plugging two component legs into row 4 holes a and c is the same as assigning them to the same reference. Plug one into row 4 hole a and the other into row 5 hole a, and they’re different variables. Nothing’s connected.

 row 4: [a]━[b]━[c]━[d]━[e]    ← all one node
 row 5: [a]━[b]━[c]━[d]━[e]    ← different node

Parts You’ll Need

  • Breadboard (half-size is fine)
  • 1 LED, any color
  • 1 resistor, 220Ω-330Ω (current limiter for the LED)
  • 1 tactile push button, 4-pin
  • 1 resistor, 10kΩ (pull-down for the button)
  • Jumper wires (M-M for board-to-board, M-F if your microcontroller has exposed header pins)
  • Pi Pico (primary) or Arduino Uno

Any decent starter kit has all of this. If you’re buying piecemeal, get a 10-pack of each resistor value. You’ll lose them.

Build the Circuit: LED + Button

Power off the Pico while wiring. Plug it into USB only after everything’s in place.

Step 1, power the rails. Run a jumper from the Pico’s 3.3V pin to the + rail. Run another from a GND pin to the - rail. The entire + column is now at 3.3V, and the entire - column is at ground.

Step 2, place the LED. LEDs are polarized. Long leg is the anode (+), short leg is the cathode (-). Put the long leg in row 10 hole a, short leg in row 11 hole a. They’re on different rows, so they’re different nodes, which is what you want, since the resistor goes between them.

Step 3, add the current-limiting resistor. Bridge row 11 (the cathode row) to the - rail using the 220Ω resistor. This is the resistor that keeps your LED from drawing too much current and dying in a flash of regret. Don’t skip it.

For the GPIO connection, run a jumper from GP15 on the Pico to row 10 (the anode row).

A quick note on pin numbers: GP15 is the GPIO number, not the physical pin number on the Pico’s header. Physical pin 20 is GP15. They’re not the same thing, and confusing them is the single most common mistake new Pico users make. Keep the official Pico pinout diagram open in a tab.

Step 5, place the button. A tactile button has 4 legs, but internally it’s just 2 pairs, connected when pressed. Position it across the center gap so each pair sits on opposite sides. One side wire goes to the + rail (3.3V). The other side goes to GP14 and through the 10kΩ pull-down resistor to the - rail (GND).

The pull-down matters. Without it, when the button isn’t pressed, GP14 is floating (not connected to anything), and it’ll read random noise. The 10kΩ resistor gently pulls the pin to ground when the button’s open, giving it a defined LOW state. Press the button and the 3.3V wins, pin reads HIGH.

   GP15 ──► [LED] ──► [220Ω] ──► GND

                        ┌─► GP14
   3.3V ──[BUTTON]──────┤
                        └──[10kΩ]──► GND

Diagram: the LED path on top (GPIO out through LED and resistor to ground) and the button path below (3.3V through button, splitting to GPIO input and through pull-down resistor to ground).

The two most common ways to mess this up:

  1. LED backwards. It just won’t light. At 3.3V you won’t damage it, just flip it.
  2. No current-limiting resistor. The LED draws as much current as the GPIO can supply, gets hot, and dies in seconds. Sometimes with a tiny pop.

Bridging to Firmware: Make It Respond

Plug the Pico in while holding the BOOTSEL button to mount it as a USB drive, drop the MicroPython UF2 onto it, then connect with Thonny (or any MicroPython REPL). Save this as main.py:

from machine import Pin
import time

led = Pin(15, Pin.OUT)
button = Pin(14, Pin.IN, Pin.PULL_DOWN)

while True:
    led.value(button.value())
    time.sleep(0.01)

Run it. Press the button. LED lights up. Release it. LED goes dark.

Walking through what each line is actually doing in the physical world:

  • Pin(15, Pin.OUT) claims GP15 as an output. That’s the wire going to the LED’s anode. The Pico can now drive it HIGH (3.3V) or LOW (0V).
  • Pin(14, Pin.IN, Pin.PULL_DOWN) claims GP14 as an input and enables the chip’s internal pull-down resistor. Technically, you didn’t need that external 10kΩ. But wiring one externally is the more transferable skill. Plenty of microcontrollers don’t have configurable internal pulls, and sometimes you need a stronger pull than the chip provides.
  • led.value(button.value()) reads the button state (1 when pressed, 0 when not) and writes it straight to the LED. The LED mirrors the button.
  • The 10ms sleep keeps the loop from pegging the CPU. You won’t notice the delay.

If you’re on an Arduino Uno instead, the wiring is identical (use 5V instead of 3.3V on the rail, and pick any digital pins). The sketch:

const int LED_PIN = 9;
const int BUTTON_PIN = 2;

void setup() {
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT);
}

void loop() {
  digitalWrite(LED_PIN, digitalRead(BUTTON_PIN));
  delay(10);
}

Same circuit, same behavior, different language and runtime. The breadboard didn’t change. The firmware did the work.

Three Variations to Try Tonight

You’ve got a working circuit and a working toolchain. Push it:

  • Toggle on press instead of mirror. Press once, LED on; press again, LED off. You’ll discover button bounce (the contact “chatters” for a few ms on each press, registering 5 toggles when you wanted 1) and have to debounce in software.
  • Add a second LED and fade it with PWM. machine.PWM on the Pico, analogWrite on the Arduino.
  • Read a potentiometer on an ADC pin and use the value to set the LED brightness. You’re now reading analog input, which opens the door to sensors.

Then break the circuit. Pull it all out, put it back together from memory, see what you forgot. Breadboards are throwaway by design. The mistakes are free, and the iteration loop is fast. Hardware stops being scary the moment you realize you can just try the thing.

Hubble Network brings Bluetooth connectivity to your prototypes at global scale, so the sensor you wired up tonight can talk to the cloud without cell modems or WiFi credentials. See how it works →