From Radiography to React: What Healthcare Taught Me About Building Software

The Unexpected Parallel

Most people find it strange when I tell them I used to be a medical radiographer. They expect the usual narrative — CS degree, internship, FAANG pipeline. My path was different. I spent years at Mayfield Specialist Hospital in Nigeria, reading X-rays and CT scans, before I wrote my first line of production code.

What surprised me most wasn't how different these worlds were. It was how similar they turned out to be.

Diagnostic Thinking Is Debugging

In radiography, you don't just look at an image — you read it. You systematically eliminate possibilities. Is this shadow a tumor, or an artifact from patient positioning? Is this fracture new, or a healed injury casting confusing geometry?

This is exactly how debugging works. When a production system goes down at 2 AM, you don't randomly change code and hope. You form hypotheses, isolate variables, and systematically narrow the fault space. The mental model is identical.

At Mayfield, I learned to trust the process over intuition. A radiographer who jumps to conclusions misdiagnoses patients. A software engineer who jumps to conclusions ships broken software. The stakes differ in magnitude, but the discipline is the same.

Patient-First Care Is User-First Design

Healthcare beats one thing into you relentlessly: the patient comes first. Not your schedule. Not the hospital's budget. Not the doctor's ego. The patient.

When I transitioned to software, this mindset translated directly. At Mayfield, I built the hospital's first digital referral platform — not because it was technically interesting, but because I watched patients wait hours in corridors that could be eliminated with a better system. That platform achieved a 42% increase in patient throughput. Not because of clever algorithms, but because I understood the pain firsthand.

This is something bootcamps and CS programs rarely teach. They teach you to build features. Healthcare taught me to solve suffering. There's a difference.

The Digital Transformation That Changed Everything

My first real engineering project wasn't at a startup. It was at Mayfield Hospital. We were drowning in paper records — patient files stacked floor to ceiling, referral letters getting lost between departments, doctors unable to access patient histories during emergencies.

I built a digital patient health records system with real-time chat between departments. We reduced the hospital's carbon footprint by 20% just by eliminating paper. But more importantly, doctors could finally access patient histories instantly. Referrals that took days now took minutes.

That project taught me something crucial: technology is only valuable when it removes friction from human processes. The most elegant code in the world is worthless if it doesn't make someone's day better.

What Healthcare Teaches You That Computer Science Doesn't

There are specific skills I carried from healthcare that I don't see discussed enough in engineering circles:

• Triage: In an emergency room, you don't treat patients in the order they arrive. You treat them in order of severity. I apply this to bug prioritization constantly. Not every P1 ticket is actually P1. The ability to rapidly assess true severity — not perceived severity — is a clinical skill.
• Informed Consent: Before any medical procedure, you explain the risks, benefits, and alternatives to the patient. In software, this translates to stakeholder communication. Before every major technical decision, I lay out the tradeoffs. No surprises. No hidden risks. Full transparency.
• Do No Harm: The Hippocratic principle. In software, this means understanding that every deployment is a potential regression. Every migration can break existing workflows. Every "improvement" has a cost. Move thoughtfully, not just fast.
• Handoffs: In healthcare, shift handoffs are sacred. You don't leave without briefing the next team. In engineering, this is documentation, code reviews, and knowledge transfer. The disciplines are identical.

Making the Leap

The transition wasn't easy. I was studying Computer Science at the University of the People while working at Mayfield. Every night after shifts, I'd code until my eyes burned. I built projects no one asked me to build. I solved problems no one assigned.

But the healthcare background became my unfair advantage. When I joined Array and helped connect 23,000+ film crew members to studios like Netflix and Universal, I approached the UX the same way I approached patient care — by understanding the pain first, then engineering the solution.

When I secured $150,000 from Microsoft for Doorcta, a peer-to-peer telemedicine platform, I wasn't pitching technology. I was pitching the reduction of human suffering I'd witnessed firsthand. The investors didn't fund my code. They funded the problem I understood better than any pure technologist could.

The Compound Advantage

Seven years into my software career, the radiography background still pays dividends. It's why I gravitate toward healthcare tech, AI-driven diagnostics, and platforms that serve real human needs.

If you're considering a career transition into tech — from healthcare or any other field — know this: your domain expertise isn't baggage. It's your moat. The world has enough engineers who can build CRUD apps. It needs more engineers who understand the domains they're building for.

The best code I've ever written wasn't clever. It was empathetic.