DEV Community: Taheera Mohammed Abdallah

Why Intellectual Property Matters to Software Engineers: Key Takeaways from Zone01 Kisumu

Taheera Mohammed Abdallah — Sat, 18 Jul 2026 12:01:07 +0000

As developers, we spend most of our time thinking about runtime complexity, clean architecture, and system scalability. But there is a parallel track that is just as critical to building sustainable technology: Intellectual Property (IP) law.

I recently attended an incredibly insightful IP training session at Zone01 Kisumu. It made me realize that understanding how software is legally protected, owned, and shared isn’t just for corporate lawyers—it’s an essential skill for the modern engineer.

Here is a technical breakdown of the four biggest pillars we covered and why they matter to your codebase.

One of the most common points of confusion in tech is the difference between copyrighting code and patenting software.

Copyright (The Expression): Copyright automatically protects the literal source code you write the moment it is fixed in a tangible medium (like saving it to a .go or .js file). It stops someone from copy-pasting your exact implementation. However, it does not stop someone from looking at your app, understanding the logic, and rewriting it from scratch using their own code structure.
Patents (The Functional Idea): Patents protect the underlying inventive concept, algorithm, or methodology, regardless of how it is written. Getting a software patent is highly complex and requires the solution to be novel, non-obvious, and utility-driven. If you hold a patent on a specific cryptographic routing method, no one else can use that method—even if they write their own codebase from scratch.

Navigating the Open-Source Ecosystem (Compliance Matters)

We all love npm install, go get, or pulling docker images. But open-source software (OSS) isn't a free-for-all; it is governed by legal licenses that dictate what you can and cannot do with it. Misunderstanding these can ruin a commercial project.

Permissive Licenses (MIT, Apache 2.0): These are developer-friendly. You can use, modify, and distribute the code commercially, usually requiring only that you include the original copyright notice.
Copyleft/Viral Licenses (GPLv3): These require that if you modify and distribute a project containing GPL code, your entire derivative work must also be made open-source under the same GPL license. If you accidentally bake a GPL-licensed library into a proprietary enterprise backend, you could legally be forced to expose your entire proprietary codebase to the public.

Work-for-Hire Agreements: Who Actually Owns the Code?

If you write code, you naturally own the copyright—unless you signed a Work-for-Hire agreement or an employment contract with specific IP assignment clauses.

In a professional setting or an apprenticeship, these contracts ensure that the intellectual property generated during work hours, or using company infrastructure, automatically transfers to the organization. As developers, it is crucial to read the fine print of your agreements to understand who owns your side projects versus your core professional contributions.

Final Thoughts

Protecting software isn't about hoarding code; it's about building a sustainable framework for innovation. Knowing how to leverage open source legally while protecting your own unique system architectures ensures that the software you build can scale safely in production and in the market.

A huge thank you to the facilitators and organizers at Zone01 Kisumu for equipping us with this crucial knowledge!

How do you approach IP and licensing in your own projects? Let's discuss in the comments below!

#programming #softwareengineering #intellectualproperty #opensource

A Beginner’s Perspective: What I Learned at Today's Backend Mini-Conference

Taheera Mohammed Abdallah — Sat, 04 Jul 2026 19:40:24 +0000

Today, I attended a brilliant backend mini-conference. As someone who is relatively new to the backend engineering world, sitting in a room full of experienced builders discussing core architecture was both incredibly eye-opening and deeply motivating.

When you're first getting started in backend development, the sheer number of tools, languages, and frameworks can feel totally overwhelming. Listening to the speakers break down four of the industry's heavy hitters—Gin (Go), Django (Python), Java, and Ruby on Rails—was exactly the conceptual map I needed.

Here is my takeaway of the big frameworks discussed today, written from a beginner trying to make sense of it all!

Gin (Go): The Minimalist Speed Demon

The speakers highlighted Gin as a go-to choice for high performance and microservices.

The Core Idea: Radical minimalism and speed.
What I Learned: Gin is incredibly fast and has a low memory footprint because it runs on Go. It doesn't force a specific project structure on you.
The Beginner Takeaway: Because it’s a micro-framework, it doesn't come with "built-in" features like an authentication system or an admin panel. You have to wire up your own architecture, which means it requires a solid understanding of backend design principles to use effectively.

Django (Python): The "Batteries-Included" Powerhouse

If you want to build features fast without reinventing the wheel, the speakers made a strong case for Django.

The Core Idea: Rapid development with massive built-in support.
What I Learned: Django follows a "batteries-included" philosophy. Out of the box, it hands you a powerful Object-Relational Mapper (ORM) to handle databases, automatic migrations, and a ready-to-use admin dashboard.
The Beginner Takeaway: It’s incredibly friendly for launching MVPs quickly, and it plays beautifully with data science and AI pipelines due to the Python ecosystem. The tradeoff is that it trades raw execution speed for developer speed.

Java: The Enterprise Backbone

You can't talk about backend engineering without talking about Java (especially Spring Boot) and its dominance in large enterprise systems.

The Core Idea: Strict structure, type safety, and massive scalability.
What I Learned:** Java’s strict type system acts like a safety net, catching bugs at compile time before the code ever goes live. It’s built to handle massive, complex architectures that need to scale reliably over decades.
The Beginner Takeaway:** The code can feel quite heavy and full of boilerplate configuration compared to the others. It takes a bit more setup to get a basic API running, but it teaches you incredible discipline regarding software design.

Ruby on Rails: The Convention King

Rails pioneered a philosophy that completely changed how modern web frameworks are built: Convention over Configuration.

The Core Idea: Developer happiness and clean, readable code.
What I Learned: Rails assumes what you want to do and handles the background setup automatically. Using its scaffolding tools, you can spin up a working application in minutes.
The Beginner Takeaway: If you follow the "Rails way," it feels like magic. The syntax is highly expressive and readable. However, like Python, it prioritizes development speed over raw execution performance.

My Biggest Lesson Today
The overarching theme from all the speakers was incredibly reassuring: There is no single "best" framework. Every tool is a series of engineering tradeoffs.
Need maximum speed, concurrency, and lightweight services? Go/Gin.
Need to ship a complete web app fast or build data pipelines? Python/Django.
Building massive, highly secure systems for an enterprise? Java.
Want massive developer velocity and elegant web architecture? Ruby on Rails.

Stepping into a mini-conference like this as a beginner can feel intimidating, but it actually did the opposite for me. It demystified the ecosystem and reminded me that at the end of the day, all these frameworks are just different ways to solve the same foundational problem: building reliable systems that serve users.

To the experienced backend devs out there: If you could go back to the very beginning of your journey, which of these ecosystems would you start with first, and why? Let's discuss in the comments!

backend #webdev #beginners #learningjourney #softwareengineering

Harnessing the Power of Bitcoin Lightning: Reflections on the Kisumu Bootcamp & Building "Sky Fee"

Taheera Mohammed Abdallah — Mon, 29 Jun 2026 07:38:46 +0000

A week ago I wrapped up an incredible, high-intensity experience at the Kisumu Lightning Developer Bootcamp, hosted right here at Zone01 Kisumu!

The bootcamp was a deep dive into the future of digital payments, focusing on the technical architectures of Bitcoin Core and the Lightning Network protocol. We spent days exploring how layer-2 scaling solutions can drive financial inclusion, enable microtransactions, and completely reshape global remittances with near-instant, low-cost settled payments.

But the real magic happened when we had to put theory into practice during the hackathon.

My team and I realized a major local challenge: parents and guardians working abroad face massive, predatory transfer fees when trying to send money back home directly for school expenses. To solve this, we built Sky Fee — a decentralized remittance solution designed to bridge the gap.

How Sky Fee works:

Global to Local: Utilizing the Go programming language, we designed a system that leverages the Bitcoin Lightning Network backend to accept near-instant cross-border payments.

Seamless Integration: To ensure practical usability on the ground, the system integrates with Safaricom’s M-Pesa Daraja API and crypto off-ramp services.

The Impact: Parents abroad can instantly pay local school fees via Lightning, which automatically settles into local mobile money currency—bypassing heavy intermediary remittance fees entirely.

Building Sky Fee with an amazing team, debugging backend nodes, and mapping out real-world fintech integrations under a tight deadline was an absolute rush. It proved just how powerful peer-to-peer developer ecosystems are when tackling real African challenges.

A massive thank you to the organizers, mentors, and the entire Zone01 Kisumu community for putting together such an impactful bootcamp. The future of global micro-payments is lightning-fast, and we are just getting started!

BitcoinLightning #LightningNetwork #Fintech #Zone01Kisumu #GoLang #MPesa #FinancialInclusion #Hackathon #Web3Remittance #DeveloperJourney