FPV Part Picker & Build Planner

A full-stack configuration and build planning platform for FPV drone hobbyists, featuring an automated, server-side rule validation architecture to guarantee part compatibility.

Project Overview & Features

Automated Compatibility Engine: Evaluates active builds against strict electronic and structural thresholds (e.g., cell count, digital/analog protocols).
Dynamic Specification Parsing: Employs C# reflection to adaptively scan hardware properties without rigid structural coupling.
Relational Architecture: Fully synchronized parts directory backed by a cloud-native database instance.
Cloud Native Lifecycle: Built with containerized staging configurations and microservices infrastructure.

Skills & Technologies Applied

C# / .NET 8 Blazor WebAssembly .NET Entity Framework ASP.NET Core Web API Cloud Architecture Containerization Neon DB (PostgreSQL) Docker OOP Restful APIs HTTP requests Webhooks

Workflow & Tools

Git + GitHub Obsidian GitHub Actions Visual Studio Railway Postman

Video Walkthrough

System Integration & Deployment

Application Dashboard

The primary interface for components tracking, custom builds creation, and live compatibility logging.

Neon Cloud Database

Serverless PostgreSQL clustering on Neon DB managing component schemas and user-generated build configurations.

Railway Cloud Engine

Continuous automated container deployments linked directly with production code repositories via Docker.

Core Engineering Architecture

Dynamic Configuration Rules


public static CompatibilityRule VoltageMatchingCheck => new()
{
    Name = "Voltage (S) Match",
    Message = "One or more components are not rated for the battery cell count (S).",
    Severity = RuleSeverity.Error,
    Check = (parts) =>
    {
        var battery = parts.FirstOrDefault(p => p.Category == ComponentCategory.Battery);
        if (battery == null) return true;

        var bSpecs = SpecValidator.GetTypedSpecs(battery) as BatterySpecs;
        var cellCount = bSpecs?.CellCount ?? 0;

        foreach (var part in parts)
        {
            var dynamicSpecs = SpecValidator.GetTypedSpecs(part);
            var maxS = dynamicSpecs?.GetType().GetProperty("MaxS")?.GetValue(dynamicSpecs) as int?;
            var minS = dynamicSpecs?.GetType().GetProperty("MinS")?.GetValue(dynamicSpecs) as int?;

            if (maxS.HasValue && cellCount > maxS.Value) return false;
            if (minS.HasValue && cellCount < minS.Value) return false;
        }
        return true;
    }
};

This verification routine evaluates electrical loads across different parts. By accessing properties through runtime reflection, the rule evaluates safety parameters like cell counts (MaxS / MinS) without hardcoding explicit models for every single peripheral component type.

Video Protocol Interoperability


public static CompatibilityRule VideoSystemMatch => new()
{
    Name = "Video System Protocol",
    Message = "Digital VTX detected with an Analog-only FC/Camera setup.",
    Severity = RuleSeverity.Warning,
    Check = (parts) =>
    {
        var vtx = parts.FirstOrDefault(p => p.Category == ComponentCategory.VTX);
        var cam = parts.FirstOrDefault(p => p.Category == ComponentCategory.Camera);

        if (vtx == null || cam == null) return true;

        var vSpecs = SpecValidator.GetTypedSpecs(vtx) as VTXSpecs;
        var cSpecs = SpecValidator.GetTypedSpecs(cam) as CameraSpecs;

        return vSpecs?.Protocol == cSpecs?.Protocol;
    }
};

To guarantee structural signals are valid before physical assembly, this engine tracks mismatch states between digital and analog transmission lines. If a high-bandwidth digital system (e.g., DJI O3, Walksnail) is matched with legacy components, the builder is immediately alerted via production warning workflows.

🔒 Project source code repository is currently private.