Software engineering Forward deployed engineering in Lusaka, Zambia

Software should keep working, and keep making sense to the people who use it, years after launch.

I've built software since 2015, working directly with clients from the first conversation through launch and support. As a forward deployed engineer, I bring that same approach into your team, combining product decisions, hands-on development and integration with your existing systems.

What I bring

  1. I understand the business and the code.

    I can work with a finance team in the morning and design the database in the afternoon, and make sure the two match.

  2. I work on the whole project.

    I handle the first conversation, mockups, testing, release, training and support after launch.

  3. I make complex systems easy to use.

    I design interfaces, documentation and reports that people can use without a manual.

  4. I document and teach.

    Your team can run the system without me, and it keeps working after the project ends.

  5. I work across borders.

    I lead delivery for a Swedish company from Lusaka and work comfortably across European and African time zones.

My work in practice

Consulting technical lead for FigureFlow AB since 2025. I build Django REST APIs and Vue 3 interfaces backed by PostgreSQL, Redis and Celery, and take each change through testing, security review and release.

Founder of ONBRD Solutions in Lusaka since 2015, where I lead software projects from requirements and mockups to delivery, training and support.

More about me
  • Python and Django
  • Django REST Framework
  • PostgreSQL
  • Redis and Celery
  • Vue 3 and TypeScript
  • React and React Native
  • Node.js and Express
  • Linux hosting and CI/CD

My view on software engineering

Engineering is mostly problem solving. The work continues after launch, because security, support and clear interfaces are part of the product. I choose the simplest design that works. Anyone can learn to build software, and teaching it is one of the best ways to understand it.

What it takes

  1. Problem first

    A lot of failed software does what it was built to do and still fails, because it solves the wrong problem or doesn't fit how people work.

    So before any code I map the requirements, the users and their workflows, including who does what, in what order, with what information, and what happens when a step fails.

  2. Fundamentals

    Frameworks change every few years. Data structures, how the web works, how databases store and query data and how version control works change very little.

    Engineers who know the fundamentals learn new tools quickly and can tell when a new tool isn't needed.

  3. Architecture that can grow

    I split code into clear modules with well-defined APIs, move slow work into background jobs and design the data model around the business. Products that serve many organisations need strict separation between each customer's data.

    Good architecture makes the next change cheap. A well-designed system can grow for years without a rewrite.

  4. Quality you can prove

    Automated tests, code review and continuous integration catch problems before users see them. Every change runs through the same checks.

    I write tests with each change, so quality work happens throughout the project.

  5. Security after launch

    Security means least-privilege access, up-to-date dependencies, patching and monitoring. A site that was secure on launch day can become exposed when someone finds a vulnerability in the software it runs on.

    Many organisations launch a system and then leave it alone. Someone has to keep it secure for as long as it runs.

  6. Delivery

    I set clear priorities, give honest estimates, release small changes often and write documentation for the people who will maintain the system.

    Training and handover matter as much as the code. A client should be able to change a label without calling me.

  7. Working with people

    Listening to users, explaining trade-offs to managers who are not engineers and teaching others are core engineering skills.

    I work every day with teams in Europe and Africa across time zones.

Anatomy of a product

Every web product is a stack of layers. Each one needs an owner, and each one fails in its own way when nobody looks after it.

Interface

What it does
What people see and touch: pages, forms, dashboards and mobile screens.
What I use
Vue 3, TypeScript, React Native
What breaks without care
Confusing screens, slow pages and errors people can't recover from.

API

What it does
The contract between the interface and everything behind it: endpoints, permissions and validation.
What I use
Django REST Framework, Node.js
What breaks without care
Data leaking between customers, rules applied differently in different places, apps that break on every change.

Background jobs

What it does
Slow work moved out of the request, such as imports, reports, emails, AI calls and retries.
What I use
Celery, Redis
What breaks without care
Timeouts, duplicate emails and jobs that silently stop.

Database

What it does
The data model, constraints, migrations and backups that hold the system's data.
What I use
PostgreSQL
What breaks without care
Corrupted data, slow queries, migrations that lock the system and no way to restore.

Infrastructure

What it does
Servers, networks, deployment pipelines and secrets.
What I use
Linux hosting, CI/CD, Cloudflare
What breaks without care
Outages, unpatched servers and deployments nobody can repeat.

Monitoring

What it does
Logs, metrics, alerts and error tracking that tell you whether the system is working.
What I use
Error tracking, logs, uptime checks
What breaks without care
Users find the problems before you do.

From commit to release

A good release runs the same checks in the same order every time. This one shows what that looks like.

release · main idle
$ ./release v2.14.0  # press Run release

Every change runs the same checks in the same order. If one fails, the release stops before anything reaches users. Turn on "Break a test" and run it again.

  • The checks run automatically, so nobody skips a step on a busy day.
  • Each change goes to a staging copy first, so production only gets changes that already worked there.
  • Health checks after each release show problems within minutes.

Zambia has the software talent, and more opportunities for it are opening up.

Zambian developers can work for international companies from Lusaka, Kitwe or Livingstone today. Remote work has made that possible, and many of the best engineers I know taught themselves most of what they know.

The industry also needs fundamentals taught early, maintenance taken seriously and systems kept secure after launch.

Working for the world from Zambia

International teams hire for skill and reliability. A strong portfolio, clear communication and good habits count for more than certificates.

Maintenance is part of the job

Public and private systems need owners who patch, monitor and improve them after launch day.

Security across the country

When someone announces a vulnerability, every exposed system in the country is at risk that day. Monitoring and patching should be routine.

Teaching the next generation

Coding belongs in schools. Children who build their own games today will build Zambia's systems later.

What we should do

  1. Teach programming fundamentals in schools.
  2. Pay for maintenance as well as launches.
  3. Monitor and patch public and private systems.
  4. Connect local developers to international work.
  5. Mentor in public by writing, reviewing code and sharing what you learn.

The feature worked in the demo, then failed in use.

The problem
A feature ships, and then people can't work out how to use it, it breaks on real data, or it doesn't solve the problem it was built for.
How I think about it
I treat design, development, testing, release and support as one piece of work. What happens after a feature ships matters as much as building it.
What I build
Software with clear permissions, review steps and recorded actions, tested against real data. I add documentation and training so the team can run it without me.
How I know it works
People use it without help, it handles failures, and months after launch it still solves the problem it was built for.

Questions people ask

Are you a software developer based in Zambia?

Yes. I'm based in Lusaka and work with organisations across Zambia in person or remotely, and with international teams remotely.

Do you build websites?

I build web applications and software products, such as platforms, portals, dashboards, APIs and mobile apps. I don't build simple brochure websites.

What technologies do you use?

Mostly Python and Django with PostgreSQL on the back end, Vue 3 and TypeScript on the front end, React Native for mobile, and Redis and Celery for background work. I pick the stack to fit the problem.

Can you review or take over an existing system?

Yes. An architecture, code or security review tells you where a system stands and which fixes to make first.

Do you lead engineering teams?

Yes. I lead engineering on a financial SaaS platform, where I set technical priorities, review code and manage releases. I can do the same for a team without a full-time technical lead.

Bring me a problem like this.

Tell me what you're trying to solve, your timeline and any constraints. I reply within two working days.