DEV Community: Millicodhiambo

How Technology Can Help SMEs Measure Their Carbon Emissions

Millicodhiambo — Tue, 01 Sep 2026 15:33:54 +0000

Climate change is often discussed at the level of governments and large corporations. We hear about national emissions targets, carbon markets, net-zero commitments, and large companies publishing sustainability reports.

*But How Technology Can Help SMEs Measure Their Carbon Emissions *

But there is another important group that is often left out of the conversation: small and medium-sized enterprises (SMEs).

SMEs make up a huge part of many economies, especially across Africa. They run restaurants, farms, shops, transport businesses, manufacturing businesses, workshops, hotels, and countless other operations.

The problem is that many SMEs want to become more environmentally responsible but don't know where their emissions are coming from or how much they are producing.

This is where technology can help.

Instead of treating carbon measurement as something only large corporations can afford, technology can make carbon accounting more accessible, automated, and understandable for SMEs.

🌍 First, What Does It Mean to Measure Carbon Emissions?

Carbon emissions measurement is essentially about answering a simple question:

«How much greenhouse gas is my business responsible for producing?»

The answer isn't limited to the smoke coming from a factory.

A business can generate emissions from many activities, including:

Electricity consumption
Fuel used by company vehicles
Generators
Cooking gas
Industrial processes
Waste generation
Business travel
Purchased goods and materials
Transportation and logistics

These emissions are usually expressed as carbon dioxide equivalent (CO₂e).

CO₂e gives us a common unit for comparing different greenhouse gases, including carbon dioxide, methane, and nitrous oxide.

💻 So Where Does Technology Come In?

Technology can help SMEs move from guesswork to measurable data.

A business could have a dashboard where it records or automatically receives information about its activities.

For example:

Electricity
↓
Smart meter
↓
Energy consumption data
↓
Carbon calculation
↓
SME dashboard
↓
CO₂e emissions

The same concept can be applied to fuel, transportation, waste, and other sources.

The goal isn't simply to produce a number.

The goal is to help the business understand:

«Where are our emissions coming from, and what can we do about them?»

Digital Carbon Calculators

The simplest place to start is a digital carbon calculator.

An SME could enter information such as:

Monthly electricity: 450 kWh
Diesel used: 120 litres
Petrol used: 80 litres
Waste generated: 300 kg

The system can then use appropriate emission factors to estimate the corresponding CO₂e.

Conceptually:

Activity Data × Emission Factor = Estimated Emissions

For example:

Electricity consumed
↓
Emission factor
↓
Estimated CO₂e

Instead of maintaining spreadsheets manually, the SME could have the calculations performed automatically.

IoT Can Provide Real-Time Data

This becomes even more interesting when we introduce Internet of Things (IoT) devices.

Instead of asking a business owner to manually record everything, sensors can collect some of the data automatically.

For example, an SME using a generator could potentially use sensors to monitor:

Fuel consumption
Operating hours
Temperature
Energy production
Equipment usage

That information can be sent to a backend system.

IoT Sensor
↓
Internet / Gateway
↓
Backend API
↓
Database
↓
Carbon calculation
↓
Dashboard

This reduces manual data entry and can make the data collection process more consistent.

3.** Smart Energy Monitoring**

Electricity is another major area where technology can help.

Smart meters and energy-monitoring devices can track how much electricity equipment or an entire facility is consuming.

_Imagine a small bakery.

Instead of estimating its electricity consumption at the end of the month, the owner could see:

Today's consumption: 18.4 kWh

Ovens: 10.2 kWh
Refrigerator: 4.1 kWh
Lighting: 2.3 kWh
Other: 1.8 kWh

The system can then estimate the associated emissions using the relevant electricity emission factor._

This provides something much more valuable than a carbon number:

visibility.

The bakery might discover that one piece of equipment is responsible for a disproportionately large amount of its energy consumption.

That creates an opportunity to reduce both emissions and operating costs.

Tracking Transport Emissions

Transportation is another area where SMEs can use technology.

A business with delivery vehicles could collect:

Distance travelled
Fuel consumed
Vehicle type
Number of trips
Delivery routes

GPS technology can help track distances, while fuel records or sensors can provide consumption data.

A platform could then estimate:

Distance + Vehicle Data + Fuel Data
↓
Emissions Estimate

Over time, the business could identify inefficient routes, excessive fuel consumption, or vehicles that require maintenance.

Again, reducing emissions can also mean saving money.

Technology Can Help Measure Waste

Waste is another important part of a business's environmental footprint.

Digital weighing systems or IoT-enabled waste containers could help businesses track:

Organic waste
Plastic
Paper
Metal
General waste

This data can then be stored over time.

For example:

January → 420 kg
February → 390 kg
March → 310 kg

Now the business has measurable evidence that its waste generation is decreasing.

For some businesses, technology could also help identify materials that can be recycled, reused, composted, or converted into other useful products.

6.** AI Can Turn Data Into Insights**

Collecting data is only half of the problem.

An SME also needs to understand what the data means.

This is where artificial intelligence can become useful.

An AI-powered system could analyse a company's historical data and identify patterns such as:

«"Your electricity consumption increased by 24% over the last three months."»

Or:

«"Your delivery vehicles account for approximately 38% of your recorded emissions."»

Or:

«"Your emissions per unit of production have decreased by 12% since January."»

Instead of simply showing graphs, the system can help turn those graphs into actionable insights.

Blockchain Could Improve Transparency

Blockchain is another technology that can potentially play a role, particularly when carbon data needs to be shared with other parties.

For example, if an SME participates in a carbon-credit programme, different stakeholders may need confidence that the underlying data hasn't been manipulated.

A system could record important verification events on a blockchain:

Business activity
↓
Collected data
↓
Verification
↓
Carbon calculation
↓
Recorded transaction

Blockchain doesn't automatically make carbon data truthful.

Garbage in still means garbage out.

If incorrect information enters the system, putting it on a blockchain doesn't magically make it correct.

But blockchain can potentially provide an additional layer of traceability and transparency once trustworthy data has been collected and verified.

SMEs Don't Need Complicated Systems

One of the biggest mistakes we can make is designing carbon-management platforms as if every SME has a sustainability department.

Most don't.

A small business owner might simply want to open an application and see:

Your Carbon Dashboard

This month

Estimated emissions
2.4 tCO₂e

Energy
1.1 tCO₂e

Transport
0.8 tCO₂e

Waste
0.5 tCO₂e

Then:

What can you improve?

Reduce generator usage
Optimise delivery routes
Improve waste separation
Switch to more efficient equipment

The technology should make sustainability simpler, not more complicated.

Why This Matters for African SMEs

There is a particularly interesting opportunity here in Africa.

Many businesses are already dealing with challenges such as:

High energy costs
Unreliable electricity
Dependence on fuel
Waste-management challenges
Limited access to sustainability tools
Limited resources for environmental reporting

A technology platform designed specifically for SMEs could connect environmental measurement with something businesses already care about:

cost.

If a system tells a business:

«"Your generator produced approximately X amount of emissions."»

That's useful.

But if it also says:

«"Your generator consumed approximately X litres of fuel, costing you approximately KSh X."»

Now the business has a financial reason to pay attention.

This is where climate technology becomes much more practical.

From Carbon Measurement to Carbon Reduction

Measuring emissions shouldn't be the final goal.

It should be the beginning.

The process could look like this:

MEASURE
↓
UNDERSTAND
↓
REDUCE
↓
VERIFY
↓
REPORT

An SME first needs to understand its baseline.

Then it can identify the biggest sources of emissions.

Then it can implement reduction strategies.

Finally, it can track whether those strategies actually worked.

A Possible Technology Stack

A relatively simple carbon-monitoring platform could be built using technologies many developers already know.

For example:

Frontend

HTML
CSS
JavaScript
React

Backend

Go
REST APIs
JWT authentication

Database

PostgreSQL or SQLite

IoT

ESP32
Energy sensors
Fuel sensors
Temperature/humidity sensors
Other appropriate monitoring devices

Data processing

Carbon emission factors
Automated calculations
Analytics

Optional technologies

Blockchain
AI
GPS
Cloud infrastructure

The important thing is that technology should serve the measurement problem, rather than adding technology simply because it sounds impressive.

What About Data Accuracy?

This is one of the biggest challenges.

A carbon platform is only as useful as the data behind it.

There are several possible approaches to improving data quality:

Automated collection

Use sensors and APIs instead of relying entirely on manual input.

Verification

Allow authorised people to review submitted data.

Audit trails

Record when data was entered, changed, or verified.

*Standardised emission factors
*
Use recognised and appropriate emission factors rather than arbitrary conversion numbers.
Clear assumptions

If an estimate is being used, the system should clearly tell the user that it is an estimate.

This last point is especially important.

A good carbon platform shouldn't pretend that an estimate is a perfectly measured number.

** The Bigger Opportunity**

Technology can turn carbon measurement from an expensive corporate exercise into something that smaller businesses can actually participate in.

Imagine a future where an SME can:

Create an account
↓
Connect energy / IoT data
↓
Track business activities
↓
Calculate CO₂e
↓
View its carbon dashboard
↓
Receive reduction recommendations
↓
Generate sustainability reports

And potentially, where appropriate and after proper verification, use that information to participate in broader carbon-market mechanisms.

That could make environmental data more accessible to businesses that have traditionally been left out.

There is an important lesson here.

We shouldn't build a platform just because we can.

A successful carbon-monitoring solution needs three things:

Good data + good methodology + useful technology.

Technology can make data collection faster.

It can automate calculations.

It can visualise trends.

It can improve transparency.

But businesses, environmental experts, auditors, regulators, and carbon-market organisations still have important roles to play.

The technology is the bridge between the data and the people who need to use it.

Final Thoughts

For SMEs, carbon measurement doesn't have to begin with a complicated sustainability department or an expensive consulting process.

It can begin with something much simpler:

data.

How much electricity are we using?

How much fuel are we consuming?

How much waste are we producing?

How far are our vehicles travelling?

Once those activities can be measured, technology can help transform them into meaningful carbon information.

And once businesses can see their emissions, they can begin making better decisions.

The future of climate technology isn't only about building massive systems for multinational corporations.

It is also about building simple, affordable tools that allow small businesses to participate in the transition to a lower-carbon economy.

Because if we want meaningful climate action, SMEs can't be left out of the equation.

What I'm Exploring

I've become particularly interested in the intersection of GreenTech, IoT, carbon measurement and software development, especially how these technologies can be adapted to solve problems faced by African SMEs.

There's a lot of work to be done — and even more to learn.

What do you think would be the biggest challenge for an SME trying to measure its carbon emissions: collecting the data, calculating the emissions, or understanding what to do with the results?

Compilation 1.0

Millicodhiambo — Mon, 17 Aug 2026 14:09:58 +0000

You write some C++ code, hit compile, and—poof—an executable appears. Or maybe it doesn’t, and you’re drowning in errors you don’t understand. Here’s the thing: compilation isn’t magic. It’s a multi-step pipeline that transforms your human-readable code into binary your computer can run. Understanding this pipeline is like getting X-ray vision for debugging. You’ll know exactly where things go wrong—whether it’s a preprocessor hiccup, a compiler syntax error, or a linker meltdown.

In this series, we’re going to pull back the curtain. We’ll walk through every stage: preprocessing, compiling, assembling, and linking. We’ll write actual code, run real commands, and see what happens at each step. No hand-waving, no “it just works.” By the end, you’ll compile with confidence and debug like a pro, or try to.

Next up, we’ll try to build a simple project to see the pipeline in action.

The Big Picture: From Text to Binary
Let’s sketch out the journey your code takes. You start with a .cpp file—just text. That file goes through four main stages before becoming an executable:

Preprocessor: Handles directives like #include and #define. It’s basically a fancy copy-paste engine that runs before the real compiler kicks in.

Compiler: Parses your code, checks syntax, builds an internal tree (called an Abstract Syntax Tree or AST), and generates assembly language—a human-readable version of machine instructions.

Assembler: Converts that assembly text into binary object files (.o on Linux, .obj on Windows). These are chunks of machine code, but they’re not runnable yet.

Linker: Glues together all your object files and any libraries (like the C++ standard library) into a final executable. This stage handles both static linking (baking code into your binary) and dynamic linking (loading shared libraries at runtime, like .so files on Linux or .dll on Windows).

Here’s a visual:

Here’s a quick visual of how source code flows through the pipeline to become an executable.

Each stage can fail for different reasons. Preprocessor errors? Usually missing headers or typos in #include paths. Compiler errors? Syntax mistakes, type mismatches. Linker errors? Missing function definitions or libraries. Knowing where you are in the pipeline makes debugging way less painful.

Setting Up Our Test Project
Let’s build something simple to experiment with. We’ll create three files: a header (source.hpp), an implementation (source.cpp), and a main program (main.cpp). Our “library” will do one thing: add two integers. Riveting, I know—but it’s enough to see every stage in action.

source.hpp (the interface):

// source.hpp
// Declares a function that adds two numbers
int add(int a, int b);
source.cpp (the implementation):

// source.cpp
// Implements the add function
int add(int a, int b) {
return a + b;
}
main.cpp (the entry point):

// main.cpp

include "source.hpp"

int main() {
int result = add(2, 3);
return 0;
}
Save these in a folder. Now let’s try compiling. On Linux with g++ installed (Ubuntu/Debian users can sudo apt install g++), run:

g++ main.cpp source.cpp -o myprogram
./myprogram
If all goes well, it compiles silently and runs (though it doesn’t print anything yet—we’ll fix that later). But what if you only compile main.cpp?

g++ main.cpp -o myprogram
You’ll hit an error like:

undefined reference to `add(int, int)'
That’s the linker complaining. It knows add exists (the compiler saw the declaration in source.hpp), but it can’t find the actual code. That’s because source.cpp was never compiled and linked in. This is our first taste of how the pipeline stages interact.

Why This Matters
Understanding compilation isn’t just academic. Here’s what you get:

Faster debugging: When you see “undefined reference,” you’ll know it’s a linker issue, not a typo in your code.

Better build systems: Tools like Make, CMake, or Ninja automate this pipeline, but they’re just orchestrating these same steps under the hood.

Smarter optimization: Ever wonder what -O2 or -O3 flags do? They tweak the compiler and assembler stages. You’ll see that soon.

Plus, if you ever work on larger projects or dive into other compiled languages (C, Rust, D, even Java’s ahead-of-time compilation), this mental model transfers directly.

Wrapping It Up
We’ve mapped out the compilation pipeline: preprocessor → compiler → assembler → linker. We’ve set up a tiny project and seen how missing a file at link-time causes errors. Next time, we’ll crack open the preprocessor and see what #include really does (spoiler: it’s simpler than you think—and more dangerous if you’re not careful).

Try compiling the code above. Experiment: leave out source.cpp and watch the linker fail. Get comfortable with that error message—you’ll see it again.

I Was Basically Gaslighted Into Learning DNS... and I'm Glad I Was

Millicodhiambo — Sun, 12 Jul 2026 19:51:37 +0000

I have a confession.

I was strongly encouraged (read: lovingly gaslighted ) into writing this article. At first, I thought, "Why me? Can't someone else do it?"

But looking back... I might actually thank the people who pushed me.

Researching DNS and writing this article taught me far more than simply listening to the tech talk we had on Friday. It forced me to ask questions, connect the dots, and understand what actually happens every time I open a website.

So, if you've ever heard people throw around the term DNS and wondered what all the fuss is about, this one's for you.

What is DNS?

Imagine you want to visit your friend's house.

You probably remember their name, not their exact GPS coordinates. So you open Google Maps, type in their name or location, and your phone figures out where to take you.

The internet works almost exactly the same way.

DNS stands for Domain Name System. Think of it as the internet's phonebook—or even better, its contacts app.

Instead of remembering an IP address like 142.250.190.78, you simply type google.com.

DNS translates that easy-to-remember name into the numerical IP address that computers use to find each other.

Without DNS, we'd all be memorizing long strings of numbers just to visit our favorite websites. Imagine trying to remember the IP addresses for Google, GitHub, YouTube, Netflix... every single day.

No thanks.

So What Actually Happens?

Let's say you type github.com into your browser.

Here's what happens behind the scenes:

Your browser asks, "What's the IP address for github.com?"
It checks with a DNS resolver to see if the answer is already cached.
If it isn't, the resolver asks other DNS servers until it finds the correct IP address.
The IP address is sent back to your browser.
Your browser connects to GitHub's server and loads the website.

All of that usually happens in just a few milliseconds.

Pretty cool, right?

Why Does DNS Matter?

DNS makes the internet much more human-friendly.

It allows us to:

Remember names instead of complicated IP addresses.
Keep using the same website address even if the website moves to a different server.
Load websites faster through caching, where recently looked-up addresses are temporarily stored.

Without DNS, browsing the internet would be a lot slower and a lot more frustrating.

Another Way to Think About It

Think of your phone contacts.

Contact Name → google.com
Phone Number → IP Address
Tapping the Contact → Opening the website

You don't memorize everyone's phone number—you save their name and let your phone handle the rest.

DNS does exactly that for the internet.

Final Thoughts

DNS is one of those technologies that's quietly doing its job every single day.

Most of us never notice it, yet every website we visit depends on it.

This article started as an assignment I wasn't exactly excited about. But by the time I finished researching and writing it, I realized I'd learned far more than I expected.

Sometimes the things we're "forced" to learn end up becoming the things that make everything else in tech start to click.

If you're just starting your journey into networking or web development, understanding DNS is a great place to begin.

My First Day at a developer Bootcamp: What I Experienced as a Beginner

Millicodhiambo — Sun, 14 Jun 2026 19:52:58 +0000

Starting a developer bootcamp is both exciting and a bit overwhelming. On my first day, I didn’t expect to understand everything—but I was ready to learn how real developers think and work.

Even though I couldn’t fully follow all the sessions later in the week, my first day still gave me a strong introduction to the journey I’m stepping into.

What stood out for me

The biggest realization was that software development is not just about writing code—it’s about problem-solving, collaboration, and consistency.

I also noticed how important tools like Git, GitHub, and development environments are in keeping projects organized.

What I learned on day one

1.The importance of having a developer mindset (learning by doing)
2.How developers structure projects and workflows
3.That it’s okay not to understand everything immediately
4.The value of consistency over speed

My bigger motivation

Beyond the bootcamp, there’s a hackathon that marks its conclusion, where I get to work on a small idea called AfriPay—a concept aimed at improving cross-border payments in Africa by integrating the Bitcoin Lightning Network.

The Lightning Network is fascinating, but still quite challenging to fully grasp. I’m still learning how it works, and I see that as part of the journey.

This experience has made me realize how important software engineering is in solving real-world problems in my region.

Even though I’m still at the beginning of my learning journey, ideas like this keep me motivated to keep going and improving every day.

My biggest takeaway

Even a single day in a developer environment can change how you see technology. It made me realize that becoming a tech junkie isn’t just about passion—it’s about discipline and continuous learning.

What’s next for me

I’m continuing to learn on my own, building small projects, and improving step by step. This bootcamp experience is just the beginning of my journey into tech.

So yeah, this is just the beginning of my journey.