It seems like every man and his dog has a drone nowadays. A simple search on amazon yields hundreds if not thousands of different results. Options exists for almost any activity, including heavy lift, inspections, filming and racing. As an engineer, there is one thing I hate about them, with a few notable exceptions, they are almost always closed source, or if they are open source they’re so convoluted it is exceedingly difficult for a layman/hobbyist to modify in a meaningful way.
This is why I am going to do something different. My goal is to design, possible a 100% DIY drone. Every component, from the flight controller to the ESCs and frame, will be designed, assembled and tested by me. I won’t be leaving you out of the picture though, I will be taking you along on the journey, sharing each step, decision and lessons learned.
This project isn’t going to be completed in a weekend. it’ll no doubt take a few months, if not years to complete.
Why DIY? Why not off the shelf?
As I discussed in the previous paragraph a lot of the off-the-shelf drones are closed source, finished products – you don’t get to see what is happening at the lower level. Of course you can buy individual components such as a flight controller, ESC and frames from various vendors, but again these are normally closed source, or, if they are open source a significant learning curve is needed before any meaningful modification can be made.
For me, the whole point to this challenge is to take control of the entire system. By going DIY, I can:
- Decide exactly how the flight controller, ESCs, and sensors are designed and connected.
- Explore control logic, signal flow, and power electronics in a hands-on way.
- Experiment with component layouts, modular designs, and custom interfaces.
- Satisfy my engineering curiosity in an informal, pressure-free way, without requirements, certification constraints, or commercial expectations
This isn’t about building a better drone than what’s on the market—it’s about designing a system that I fully understand and control, piece by piece. For someone who enjoys tinkering, testing, and seeing ideas come to life in hardware, that freedom is hard to beat.
What “100% DIY” Actually Means (and What is Doesn’t)
At a hobbyist level, building a truly 100% DIY drone is functionally impossible. I don’t have the facilities to fabricate silicon for microcontrollers, nor the machining capability to manufacture high-performance brushless motors.
For the purposes of this series, “100% DIY” means designing, building, and testing everything that is practical to do myself. Where that isn’t feasible, I’ll rely on commercially available components. I won’t be fabricating my own microcontrollers, sensors, or motors—but I will be designing the system architecture that integrate, controls, and powers them.
Practically this means, I will be developing the following aspects of my drone:
- A flight controller – including electrical aspects (Schematic and PCB) and the firmware (Sensor Fusion, Control Laws, Control Links etc)
- An RC Transmitter so the pilot (me) can control the drone from the ground.
- A Custom Smart ESCs designed and tested as standalone power electronics
- A Custom video system – id love to have a low latency and high definition video recording/transmitting facilities
- A Custom Frame – designed with modularity in mind
This approach allows the project to stay grounded and achievable, while still covering the parts of the system that are most interesting from an engineering and experimentation perspective. It’s not about building everything from raw materials—it’s about designing a complete, understandable, and modifiable flying system from the ground up.
Learning Goals
Although this project sits firmly in the hobby space, I intend to approach it like a real engineering programme—just one where I happen to be the customer, project engineer, systems engineer, design engineer, and manufacturing engineer all at once. The objective is to exercise engineering discipline across a complete aerial platform: defining interfaces, making architectural trade-offs, developing hardware and firmware, and validating design decisions through structured testing.
Rather than optimizing individual subsystems in isolation, the focus is on system integration—exploring how sensing, control, communications, power, and structure interact when implemented in real hardware. The challenge is not simply to make each component work, but to understand how design decisions propagate across the entire system.
In my day-to-day work, I deal with aircraft worth tens of millions of pounds. At that scale, there is little room for experimentation—every design decision must be formally justified, validated, and verified long before anything ever flies. This project provides a different environment: a technical sandbox where I can explore design margins, failure modes, and implementation trade-offs that would be impractical to investigate in a certified or commercially constrained programme.
By iterating on custom hardware and firmware and observing their behaviour in flight, the aim is to build a deep, end-to-end understanding of system performance—from sensor acquisition and control laws through to motor actuation and physical response—while maintaining a pragmatic, test-driven approach appropriate for a non-certified, experimental platform.
What this project is not
I don’t think I need to say it, its probably already obvious at this point, but there is no intention to develop this project into a commercial project, reference design or production ready design. It certainly is not meant to meet the certification, regulatory requirements. When I take design decisions, they will be driven by a) what I am currently interested in b) practicality and c) the desire to experiment – very little credit will be given to being easy to manufacture at scale or compliance to an arbitrary set of certification requirements. Furthermore, the end result of this project is not meant to be a competitor to the likes of DJI, Parrot or established open source alternatives. Instead this project focuses on understanding and controlling the system architecture end-to-end, even when that means making trade-offs that would be unacceptable in the real world. Finally, whilst I hope you learn a lot from my progress over the next few months and years, please do not consider this series of blog posts as a tutorial, there is no guarantee that this project will result in a viable drone, there is always the possibility it ends up as a pile of burning batteries an molten plastic. I fully expect this project to be full of failures, redesigns and dead ends – The value of the project lies in exploring design decisions, observing real-world behaviour, and iterating on a complete system—not in presenting a polished or prescriptive solution.
Design Approach
Rather than attempting to design and build the entire system in a single pass, this project will follow a deliberately incremental and modular development approach. Each subsystem will be designed, implemented, and brought to a stable baseline independently before being integrated into the wider platform. That doesn’t mean a subsystem is ever “finished”—the flight controller, for example, will continue to evolve as integration and flight testing expose opportunities for refinement. Instead, the goal is to focus on one element at a time, progressing it to a level of maturity where it can be meaningfully integrated with the rest of the system.
Working in this modular fashion provides several advantages. First, it allows costs to be managed more carefully—this is a hobby project, not a funded programme with an unlimited budget. Second, it enables deeper technical focus on each subsystem in isolation, reducing cognitive overload and increasing the likelihood of producing robust, well-understood designs. Finally, it supports controlled iteration: improvements identified during integration or testing can be incorporated without destabilising the entire platform at once.
Keeping the project Hobby Friendly
Although I’m approaching this with an engineering mindset, it’s important that the project remains firmly rooted in the hobby space. That means keeping designs practical, accessible, and achievable without specialist facilities or unrealistic budgets. Wherever possible, I’ll favour commonly available components, tools that can be used on a typical workbench, and manufacturing methods that hobbyists can realistically replicate—such as standard PCB fabrication services, off-the-shelf materials, and straightforward assembly techniques. The goal is not to create an over-engineered science experiment, but a project that remains enjoyable, sustainable, and grounded in real-world constraints. By keeping the scope sensible and the tooling accessible, the project stays true to its purpose: an experimental, hands-on engineering effort that can evolve organically without becoming prohibitively complex or expensive.
The bigger picture
While this project is ultimately a personal engineering exercise, it reflects a broader idea: complex systems become far more understandable when you take ownership of their architecture end-to-end. Modern drones—and modern engineering in general—often rely on deeply layered abstractions and opaque subsystems that make it easy to use technology without ever truly engaging with how it works. By stepping back and rebuilding a platform from the ground up, even at a hobbyist level, it becomes possible to reconnect with the fundamentals of sensing, control, power, communications, and structure as a cohesive system rather than a collection of interchangeable modules. The intention isn’t to reject existing technology, but to explore it from first principles—to better understand the trade-offs, constraints, and emergent behaviours that only become visible when you design, integrate, and test a complete system yourself. If nothing else, this project is a reminder that engineering curiosity doesn’t have to stop at the workplace; sometimes the most interesting exploration happens when you’re free to experiment on your own terms.