Your First Real PCB in KiCad : An Arduino Compatible Board Designed from Scratch

cstanton — Thu, 16 Apr 2026 14:20:10 GMT

Current Revision posted to Documents by cstanton on 4/16/2026 2:20:10 PM

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

players.brightcove.net/.../index.html

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

Tags: attiny3226 development board, arduino uno compatible pcb, e14presents_mayermakes, kicad tutorial, kicad templates arduino, kicad schematic workflow, pcb layout and routing basics, four layer pcb design, usb-c pcb design, custom microcontroller board, usb to uart interface design, kicad 10 tutorial, kicad symbol footprint libraries, PCB design for beginners, kicad 9 tutorial, friday_release, open source hardware arduino, updi programming attiny

Your First Real PCB in KiCad : An Arduino Compatible Board Designed from Scratch

cstanton — Thu, 16 Apr 2026 12:30:39 GMT

Revision 5 posted to Documents by cstanton on 4/16/2026 12:30:39 PM

Watch the Full Unedited KiCad Tutorial

players.brightcove.net/.../index.html

A Hands‑On, Step‑by‑Step Introduction to KiCad

“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

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.

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

Your First Real PCB in KiCad : An Arduino Compatible Board Designed from Scratch

cstanton — Thu, 16 Apr 2026 12:26:09 GMT

Revision 4 posted to Documents by cstanton on 4/16/2026 12:26:09 PM

Watch the Full Unedited KiCad Tutorial

players.brightcove.net/.../index.html

A Hands‑On, Step‑by‑Step Introduction to KiCad

“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

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.

Supporting Files and Links

- Austroduino Github Repository (Mirror Snapshot)

Your First Real PCB in KiCad : An Arduino Compatible Board Designed from Scratch

cstanton — Thu, 16 Apr 2026 12:25:17 GMT

Revision 3 posted to Documents by cstanton on 4/16/2026 12:25:17 PM

Watch the Full Unedited KiCad Tutorial

players.brightcove.net/.../index.html

A Hands‑On, Step‑by‑Step Introduction to KiCad

“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

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.

Supporting Files and Links

- Austroduino Github Repository (Mirror Snapshot)

Your First Real PCB in KiCad : An Arduino Compatible Board Designed from Scratch

cstanton — Thu, 16 Apr 2026 12:17:21 GMT

Revision 2 posted to Documents by cstanton on 4/16/2026 12:17:21 PM

Watch the Full Unedited KiCad Tutorial

players.brightcove.net/.../index.html

A Hands‑On, Step‑by‑Step Introduction to KiCad

“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

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.

Supporting Files and Links

- Austroduino Github Repository (Mirror Snapshot)

Your First Real PCB in KiCad : An Arduino Compatible Board Designed from Scratch

cstanton — Thu, 16 Apr 2026 11:32:32 GMT

Revision 1 posted to Documents by cstanton on 4/16/2026 11:32:32 AM

Watch the Full Unedited KiCad Tutorial

players.brightcove.net/.../index.html