How ‘Cherrypicking’ Undervalued Tech is Accelerating Automotive Software Innovation

Modern cars are rolling computers. They run millions of lines of code, manage real-time safety systems, and stream your favorite playlist — all at 70 mph. As an automotive software engineer with over ten years under the hood, I’ve worked on everything from infotainment to ADAS and body controls. One thing keeps standing out: the biggest leaps forward? They rarely come from shiny new tools. More often, they come from reusing what already works — but in smarter ways.

Call it “cherrypicking.” It’s not lazy. It’s smart. It’s how we build connected cars that actually work — faster, cheaper, and more reliably — by finding hidden gems buried in old systems, open-source codebases, and nearly forgotten protocols.

The Hidden Power of ‘Cherrypicking’ in Automotive Software Development

When I say “cherrypicking,” I don’t mean skipping hard work. I mean spotting undervalued tools — a stable library, a reliable protocol, a forgotten middleware trick — and giving them new life in modern automotive software stacks.

Think of it like restoring a classic car. You don’t rip out the entire drivetrain just because it’s older. You tune it, upgrade the electronics, and make it sing. The same goes for software. Whether it’s a battle-tested CAN stack, a lightweight UI library that never got its due, or a simple message protocol built for low bandwidth — these aren’t relics. They’re assets.

And in today’s world of connected vehicles, where every second counts and every byte matters, these overlooked components can be your secret weapon.

Why This Matters Now

Software-defined vehicles (SDVs) are the future. But building them from scratch? Risky. Expensive. Time-consuming. With OEMs racing to deliver OTA updates, cloud integration, and personalized driver experiences, full greenfield builds often hit delays — or fail under real-world stress.

That’s why smart teams are turning to strategic reuse. Not copy-pasting old code. But recognizing which parts of the past still solve today’s problems — better than anything new.

“The best engineers don’t just build—they combine.” – Inspired by the quiet legends who’ve kept 20-year-old CAN networks running flawlessly across millions of miles.

1. Reusing the CAN Bus: The Undervalued Backbone of Connected Cars

The Controller Area Network (CAN) bus has been around since the 80s. Sounds ancient, right? But it’s still in 90% of vehicles for a reason: it’s rock solid. Reliable. Deterministic. Low-latency. And yes — still fast enough for most vehicle data.

Instead of dismissing it as “legacy,” I’ve used CAN’s low overhead and real-time behavior to build modern gateways that connect legacy ECUs to the cloud — no rebuilds, no rewrites.

Actionable Use Case: CAN-to-Cloud Gateway

For an EV telemetry project, we needed real-time vehicle data in the cloud — without a full ECU rewrite. The trick? A CAN-to-MQTT bridge using can-utils and mosquitto, leveraging an old but bulletproof CAN parser from an AUTOSAR stack.

We wrapped it in a lightweight embedded Linux service on a Raspberry Pi Compute Module 4. Result? A working prototype in weeks, not months.

Here’s the core logic — simple, but effective:


#include #include

void on_can_message(struct can_frame *frame) {
char topic[64];
sprintf(topic, "vehicle/%03X", frame->can_id);
mosquitto_publish(mosq, NULL, topic, frame->can_dlc, frame->data, 0, false);
}

// Run on embedded Linux, using socketcan
int main() {
struct mosquitto *mosq = mosquitto_new(NULL, true, NULL);
mosquitto_connect(mosq, "iot.cloud.auto", 1883, 60);

int s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
bind(s, (struct sockaddr*)&addr, sizeof(addr));

while (1) {
read(s, &frame, sizeof(frame));
on_can_message(&frame);
}
}


This cut telemetry latency by 40% and saved us six months of development. Why? We didn’t rebuild CAN. We respected it.

2. Infotainment Systems: Borrowing from Forgotten UI Frameworks

Modern dashboards need slick UIs. But defaulting to Qt or Android Automotive OS can bloat the system and slow boot times. I’ve found better performance — and faster builds — by cherrypicking lightweight UI frameworks from other embedded domains.

Enter LVGL — a free, open-source GUI library built for microcontrollers and RTOSes. It’s tiny, touch-ready, and compiles under 1MB. Originally used in medical devices and industrial panels, it’s perfect for high-reliability in-car displays.

Code Reuse: Integrating LVGL with Qt Quick

We built a hybrid infotainment stack by running LVGL in a separate process, then using the Wayland protocol to blend it with Qt Quick:

• LVGL for critical vehicle data (speed, battery, warnings — sub-100ms response)

<

• Qt Quick for navigation, media, and apps
• Shared memory + D-Bus for smooth communication

The payoff? Boot time dropped from 8 seconds to 3.2. Memory use? Down 35%. All because we didn’t build a new graphics engine. We found one that already worked.

3. IoT and OTA: The Rediscovery of Lightweight Protocols

Connected cars don’t always have strong signals. Data has to be lean. While many teams default to HTTP or gRPC, I’ve had more success with CoAP (Constrained Application Protocol) — a lightweight, REST-like protocol built for IoT.

And for rural fleets? I’ve adapted LoRaWAN-inspired messaging principles — tiny packets, deep sleep modes, low data rates — to keep vehicles updating even when coverage is spotty.

Example: Using CoAP for Edge Updates

For a delivery fleet with weak cellular in remote zones, we built an OTA system using CoAP over UDP. With libcoap in the firmware, we got:

• 90% less bandwidth than HTTP
• Multicast updates (push to 100 vans at once)
• DTLS encryption built-in

The update handler was simple, but critical:


COAP_DEFINE_HANDLE_RESOURCE(update_resource, "update", handle_update_request);

void handle_update_request(coap_context_t *ctx, coap_resource_t *res, coap_session_t *sess, coap_pdu_t *req) {
// Validate signature, apply patch, reboot
apply_firmware_update(req->data, req->length);
coap_pdu_set_code(res, COAP_RESPONSE_CODE_CHANGED);
}


CoAP isn’t flashy. But for IoT-scale automotive, it’s perfect — efficient, secure, and built for the real world.

4. Embedded Systems: The Case for Legacy RTOS Wisdom

Safety-critical ECUs still run on FreeRTOS, QNX, RT-Thread — and for good reason. These systems are proven. But new teams often ignore the patterns that made them robust in the first place.

I’ve saved months of debugging by revisiting old RTOS design patterns — like memory pools, message queues, and watchdog timers — instead of chasing the latest AI-powered middleware.

Pattern: The “Double-Buffered CAN Handler”

Once, we had random ECU resets during heavy CAN traffic. Instead of rewriting the stack, I adapted a 2008 design from engine control units: double-buffering.

Here’s how it works:

1. CAN driver writes to buffer_A
2. On interrupt, switch to buffer_B
3. Let a background thread process buffer_A
4. Repeat — no lockups, no overflows

Result? 95% fewer CAN errors. And zero extra CPU load. We now use it across all high-throughput ECUs.

5. The Mindset Shift: From Innovation to Integration

Too many teams think innovation means starting from zero. But in automotive software, the real breakthroughs come from combining the right pieces — old and new.

Ask yourself:

• Is there a mature open-source project that already solves my core problem?
• Which legacy protocol has proven itself in millions of vehicles?
• Can I extend, wrap, or adapt instead of rewriting?

Cherrypicking isn’t about cutting corners. It’s about building smarter. It’s respecting the engineering that came before — and asking, “How can this work for us, right now?”

Conclusion: The Future Belongs to the Curious

The next generation of in-car software won’t come from one revolutionary tool. It will come from engineers who know how to cherrypick the right pieces — a forgotten CAN trick, a lightweight UI library, a simple but brilliant RTOS pattern — and stitch them into something powerful.

My “best find” this year? Not a new SDK. Not a trendy framework. It’s a mindset: that the best solutions are often hidden in plain sight — in 1980s embedded code, 2000s open-source projects, or a veteran’s notebook.

Start small. Audit your stack. Look for what’s already working. Then build on it. The future of connected cars isn’t just about writing new code. It’s about curiosity, context, and the courage to reuse.

Related Resources

You might also find these related articles helpful:

• How to Build a Winning LegalTech E-Discovery Platform in 2025: Lessons from the World’s Best ‘Cherrypicks’ – Technology is reshaping the legal field, especially in E-Discovery. After spending years building and advising on LegalT…
• The HealthTech Engineer’s 2025 Cherry-Pick: Building HIPAA-Compliant Telemedicine & EHR Software That Scales – As a HealthTech engineer building telemedicine and EHR systems, I’ve seen firsthand how HIPAA compliance can make …
• How Sales Engineers Can Automate High-Value Deal Hunting With Salesforce & HubSpot Integrations – Great sales teams don’t just work hard—they work smart. And the secret? The right tech in the right hands. If you’re a s…