.jpg)
Clem takes on the challenge of designing a fully Arduino Uno–compatible development board using KiCad, guiding viewers through the entire process from template selection to a manufacturing-ready PCB. Instead of abstract theory, the video focuses on real design decisions, including choosing an ATtiny3226 that doesn’t yet exist in an Uno form factor, handling USB‑C power and data safely, integrating UPDI programming, and avoiding common schematic and layout mistakes that can derail a first board. Along the way, Clem highlights practical hurdles—such as matching symbols to real footprints, managing logic-level compatibility, routing USB data lines, and running proper design rule checks—while explaining how KiCad’s tighter schematic-to-PCB integration makes iteration easier. The result is a clear, hands-on walkthrough that shows not just how to use KiCad, but how to think like a PCB designer when building reliable, reproducible hardware.
Watch the Full Unedited KiCad Tutorial
A Hands‑On, Step‑by‑Step Introduction to KiCad
Designing a printed circuit board can feel intimidating at first, especially if you’ve never used a professional‑grade CAD tool before. KiCad exists to lower that barrier. KiCad is a free, open‑source, cross‑platform PCB design suite that brings schematic capture, PCB layout, 3D visualisation, and manufacturing outputs into one integrated workflow. Clem uses KiCad exactly as it’s meant to be used: not as a collection of isolated tools, but as a complete, end‑to‑end design environment. Clem walks through the full design of a real, buildable board, following the same workflow you’d use on an actual engineering project.
“Rather than focusing on theory, this is something useful that you could use in your electronics journey if you follow along.”
You can follow along with this blog, but the meat of the guide is in Clem's extended video.
Why KiCad, and Why This Project?
KiCad is chosen because it:
- Keeps schematic and PCB views tightly linked
- Allows one‑click updates from schematic to layout
- Has built‑in electrical and design rule checking
- Is supported directly by modern PCB manufacturers
That makes it especially well‑suited to beginners who want professional results without commercial licensing costs. Just as importantly, Clem chooses a real project: an Arduino Uno compatible development board.
Arduino’s hardware is open source, which means you’re allowed to design your own versions.
“Arduino is open source, so you can make your own version. I’m going to use one that doesn’t exist yet.”
The board uses an ATtiny3226, a modern AVR that can run at both 3.3 V and 5 V — a decision that influences almost every design step that follows.
Step 1: Start Smart - Create a Project from a Template
Instead of starting with a blank canvas, Clem uses project templates.
In File → New Project from Template, KiCad offers ready‑made templates for platforms like:
- Arduino
- Raspberry Pi
- BeagleBone
- Other common form factors
Clem selects the Arduino Uno template, which immediately locks down:
- Board outline
- Mounting hole positions
- Header spacing and alignment
“If you want to adhere to a specific pinout or standard of board… you choose a new project from template.”
This eliminates an entire class of mechanical errors before any schematic work begins — shields will fit, headers will line up, and the board will physically behave like an Arduino.
Step 2: Understand KiCad’s Two Core Editors
At this point, Clem pauses to explain how KiCad is structured.
KiCad is made up of several tools, but two matter most here:
The Schematic Editor
This is where electrical intent lives:
- What connects to what
- Power distribution
- Signal naming
- Functional grouping
The PCB Editor
This is where those electrical connections become:
- Pads
- Tracks
- Vias
- Copper planes
A key KiCad improvement is how tightly these are linked. Clem keeps both open at the same time, often on separate screens. Clicking a component in one highlights it in the other.
That feedback loop is what makes KiCad feel fast instead of fragile.
Step 3: Schematic First - Think Function, Not Appearance
Clem’s first real design rule is simple:
“Don’t think about how the board will look when you’re doing the schematic. This is only about the function.”
In the schematic editor, he:
- Places all required components first
- Uses labels instead of long wires to keep things readable
- Uses global labels for power nets
- Marks unused pins with no‑connect flags
These habits work directly with KiCad’s Electrical Rules Checker (ERC), which will later flag:
- Missing connections
- Forgotten pins
- Ambiguous nets
This is where a lot of beginners go wrong, and where KiCad actively helps you catch mistakes early.
Step 4: Design Power with Flexibility in Mind
Instead of hard‑coding a single operating voltage, Clem designs for choice.
The ATtiny3226 can run at either 3.3 V or 5 V, so Clem adds:
- A USB‑derived 5 V rail
- A regulator to generate 3.3 V
- A jumper that selects which voltage powers the microcontroller
“This chip can do both if you want to… I want to have adjustable operating voltage, which in turn changes the logic levels.”
Because the board is USB‑powered only, this decision affects:
- Regulator choice
- USB protection
- Logic‑level compatibility across the board
This step shows how early architectural decisions ripple forward into later design stages.
Step 5: Add USB‑C — but Keep It Sensible
USB‑C often scares people off. Clem deliberately avoids that by targeting USB 2.0 only.
That keeps routing manageable while still delivering modern connectivity.
Key points Clem covers:
- Correct CC resistors so the board actually gets power
- A Schottky diode to prevent back‑powering a PC
- Choosing a USB‑to‑UART bridge that tolerates both 3.3 V and 5 V logic
“One thing I always check in the datasheet is: can this part really work with the different logic levels that I want?”
Because the ATtiny3226 doesn’t natively support USB, the USB‑to‑UART chip becomes a realistic, well‑explained trade‑off.
Step 6: Build UPDI Programming Directly Onto the Board
Instead of relying on an external programmer, Clem integrates UPDI programming directly.
Using a dual‑throw switch, the same USB connection can be switched between:
- UPDI programming mode
- Normal UART operation
“We’re building our programmer directly into the board… this lets us choose between UPDI mode and normal operation.”
This section highlights an important engineering habit: reusing proven design patterns, but understanding why they work instead of blindly copying them.
Step 7: Assign Symbols and Footprints That Match Reality
Once the schematic is complete, Clem moves into a step that beginners often underestimate: footprints.
Rather than trusting generic placeholders, he:
- Downloads manufacturer‑provided symbols and footprints
- Imports them into KiCad
- Cleans them up so pin names and orientation match the real parts
“It’s better to have a symbol and a footprint that actually belong to each other.”
This dramatically reduces the risk of assembly errors later and plays directly to KiCad’s strong library‑management tools.
Step 8: Push the Schematic into the PCB Editor
With footprints assigned, Clem clicks Update PCB from Schematic.
All components appear on the board, connected by thin lines called the ratsnest. Nothing is routed yet, this is KiCad showing what must eventually connect.
This is where schematic decisions start paying off.
Step 9: Place Components Before Routing
Clem doesn’t route immediately.
Instead, he:
- Places the microcontroller first
- Moves connectors to board edges
- Keeps decoupling capacitors close to their ICs
- Groups related circuitry together
“I get them in the general area first, and then I move them while I’m routing.”
Good placement makes routing easier, cleaner, and less frustrating.
Step 10: Route the Board Iteratively
Routing starts with the easy connections and builds up.
Clem demonstrates:
- Slightly thicker traces for power (for visibility as much as current)
- Differential‑pair routing for USB data
- Short ground connections dropped straight into vias
- Gradual refinement rather than perfection on the first pass
Although the board could be routed with two layers, Clem switches to four layers for EMC reasons.
“Four layer boards are usually done because of EMC… even if you don’t really require them for routing.”
Step 11: Ground Planes, Stitching, and “Good Enough” EMC
Ground planes are added and stitched together with vias.
Clem’s philosophy here is pragmatic:
- Solid ground connectivity is almost always beneficial
- Via stitching is cheap
- Modern PCB fabs don’t penalise you for doing it properly
This isn’t about theoretical perfection, it’s about robust, real‑world boards.
Step 12: Label, Document, and Sanity‑Check Everything
Before ordering, Clem:
- Adds clear silkscreen labels (front and back)
- Adds version numbers
- Adds licensing information (CC BY‑SA, matching Arduino)
Then he runs KiCad’s Design Rules Checker.
“That would have been a really bad mistake.”
Several issues are caught here — exactly the kind that are easy to miss by eye.
Step 13: From KiCad to Manufacturing
Finally, Clem uploads the native KiCad project files directly to a PCB manufacturer.
No Gerber export required.
“It’s very easy to go from a finished design to an order‑ready PCB.”
This reflects a modern workflow where design, checking, and manufacturing are tightly linked.
Getting Used to Repeatable Process
Check out Clem's schematics below, inspect every decision, and recreate the project step by step alongside the video or out of your own curiosity.
“If this was too fast for you, check out the full unabridged version… recreate the tutorial side by side.” - Clem
If you'd prefer a more abridged version, you can find it on our YouTube Channel.
By keeping the focus on real decisions, honest trade‑offs, and KiCad’s modern workflow, Clem delivers something more valuable than a feature tour: hopefully a practical way to start designing PCBs with confidence.
Supporting Files and Links
- Austroduino Github Repository (Mirror Snapshot)
Bill of Materials
| Product Name | Manufacturer | Quantity | Buy Kit |
|---|---|---|---|
| Attiny3226 | microchip | 1 | Buy Now |
| Molex usb-c | molex | 1 | Buy Now |
| MCP1825s33 | microchip | 1 | Buy Now |
Top Comments