Zamacore Blog

Low Code Software Development in Kenya: Speed Without a Dead End

Low Code Software Development in Kenya

low code software development in Kenya usually arrives through a finance team that has waited eight months for a small approval app.

Someone discovers a platform, builds the thing in a fortnight, and the business saves real money before anybody asks about support.

low code software development in Kenya is a good answer to that problem, and a poor answer to several others.

Where Low Code Earns Its Place

Low code suits processes that are simple, internal and still changing, used by a known group of people for a defined purpose.

An approval workflow, a site inspection checklist, a leave request, a supplier onboarding form: these are forms plus rules plus a queue.

Count the integrations before the forms. A form that must read stock and write an invoice is an integration project wearing a form’s clothes.

low code software development in Kenya should name the shape before naming the platform. If the requirement is a form and a report, low code fits.

If the requirement is a pricing engine, a payroll calculation or a reconciliation across three systems, it probably does not.

The test is the number of decisions per transaction. Two or three decisions, each with a clear rule, is low code territory.

Twenty decisions with exceptions, delegations and a regulator watching is not, however good the demo looks.

low code software development in Kenya also suits the department that needs something this quarter and can accept a standard interface.

Custom user experience, offline field work and high-volume transactions are the edges where the platform starts to fight back.

Any process with a statutory deadline belongs on the careful list as well, because a missed filing is not a user experience issue.

Write the fit criteria before the demo, because a good sales engineer can make any platform look suitable for anything.

Score each candidate process out of ten on volume, decision count, integration count and expected life. Below twenty-five, look again.

The Citizen Developer Temptation

The promise is that business people build their own tools, and the finance department stops waiting for IT.

The first two apps are a triumph. The third is a stock tracker that duplicates the ERP, and the fourth is a payroll calculation nobody can audit.

low code software development in Kenya usually fails not at the first app but at the twentieth, when the builders have left their departments.

Citizen developers need a lane, not a ban. Let them build forms, checklists and small trackers, with a register and a review date.

Give them a sandbox, a naming convention and a template, and the apps arrive tidier than anything built in a personal account.

low code software development in Kenya should define what they may not touch: money movement, statutory returns, patient data, anything involving an external party.

Every citizen-built app needs an owner, a purpose and an expiry date. Without those three, the estate fills with orphans.

Publish the register where IT can see it. A list nobody reads is not governance, it is an archive.

Encourage the business analyst who understands the process. Discourage the enthusiast who mainly enjoys the tool.

low code software development in Kenya with a platform team behind it turns curiosity into capacity, rather than into a support queue for IT.

Review the register every quarter and retire what nobody uses. Deletion is a governance function, not a loss.

Data Ownership and the Exit Clause

The data in a low code app belongs to the business, but the shape it takes can belong to the platform.

Ask three questions before the first record: where does it live, what can I export, and what happens on termination.

Add a fourth: who else can read it. A platform that shares data with its own analytics service has changed the answer.

low code software development in Kenya should insist on a full export in a documented format, including attachments and history, not only current rows.

A spreadsheet of the main table is not an exit. Look for the audit history, the workflow states and the attached documents.

A restore should be tested into a clean environment, because a backup nobody has restored is a rumour.

Data residency matters under the Data Protection Act. Know which country holds the replica, not only the primary database.

Ask for the sub-processor list. The platform you contracted may run on three others you have never assessed.

low code software development in Kenya with a deletion certificate at exit avoids the awkward discovery that records survive the contract.

Put the exit test in the agreement as a deliverable, with a date and a named owner on each side.

A platform that cannot be left cheaply is a platform that can raise its price with confidence.

M-PESA and eTIMS Integrations

Almost every Kenyan business process eventually touches a payment and a tax invoice.

M-PESA integration means Daraja, a shortcode, credentials, callbacks and a reconciliation that survives a timeout.

Go-live on Daraja needs a production shortcode, a whitelisted callback URL and a certificate that does not expire quietly.

low code software development in Kenya should treat the payment as a state machine: initiated, pending, confirmed, failed, reversed. A callback is not a guarantee.

Test the timeout path first. A customer who pays twice because the first callback was slow is a refund and a complaint.

low code software development in Kenya must store the M-PESA receipt number against the transaction, or the bank reconciliation becomes guesswork.

eTIMS integration is stricter. The invoice payload must carry the right tax treatment, and the response must be stored.

low code software development in Kenya should treat a rejected invoice as a first-class outcome, with a queue, a reason and a person responsible.

Both integrations are regulated and both change. Keep the mapping in one place, documented, with a test environment.

Reconcile daily between the platform, the payment provider and the bank. Three sources that agree are worth more than one that is trusted.

Sandbox success is not production readiness. Run a small live pilot with a real shortcode before the volume arrives.

Per-User Pricing at Two Hundred Seats

Low code is priced per user per month, and the number looks small until it meets a Kenyan headcount.

At thirty dollars a user, two hundred users cost seventy-two thousand dollars a year before implementation begins.

low code software development in Kenya should model the licence against the whole population, not the department that started the project.

Separate the people who create from the people who approve and the people who only read. Many platforms price them differently.

Read-only users can be most of the organisation. If they are charged as full seats, the business case changes shape.

low code software development in Kenya should count external users: suppliers, agents, field staff and customers, because guest pricing is often higher.

API calls and storage form the second invoice. A busy integration can exhaust a plan that looked generous in the demo.

low code software development in Kenya should include the renewal uplift. Ten per cent a year compounds faster than most budgets allow.

Compare the three-year licence total with the cost of a custom module maintained in-house.

A platform that costs more each year than the process is worth is a subscription to overhead.

Negotiate on volume before the pilot ends. Bargaining power exists while the contract is unsigned and disappears afterwards.

Performance Ceilings You Only Meet Later

Every low code platform has a ceiling, and the demo never reaches it.

Ten thousand records behave beautifully. A million records with a report across four tables is a different product.

low code software development in Kenya should be tested with production-like volume before rollout, not after finance imports three years of history.

Ask about concurrency: how many users can submit at the same moment on the last day of the month.

Month-end is the honest test. Load the platform on a day when finance runs three reports and a hundred people approve.

The limits on rows, API calls, file size and background jobs should be published in writing.

Long-running calculations belong outside the platform, in a service that can be monitored and retried.

low code software development in Kenya gives a clean exit when the ceiling is reached: move the heavy logic behind an API and keep the interface.

Design the data model for the volume expected in three years, not the pilot running this month.

A slow app is worse than a paper form, because people trust the number and stop checking it.

Monitor response time as an operational metric, with a threshold and a named owner when it is breached.

Shadow IT and the Spreadsheet Estate

Most Kenyan mid-sized companies already run a low code estate made of spreadsheets and email.

The stock report is a workbook with a macro, the debtor list is maintained by one person, and the payroll reconciliation lives on a laptop.

low code software development in Kenya should inventory that estate before selling a platform. The spreadsheet is both the competitor and the requirement document.

Each workbook is a process with hidden rules, and those rules are the valuable part.

Interview the person who maintains it before looking at the formulas. They will describe the exceptions the sheet never shows.

Rank the workbooks by the cost of an error, not by how often they are opened. The quiet one that feeds a statutory return matters most.

low code software development in Kenya can replace the worst five with a governed app, which often pays for the first year.

Do not replace all of them. A monthly report that works is not a problem to solve.

low code software development in Kenya should give each spreadsheet a retirement date and a named successor process, or it will return.

The risk in shadow IT is not the tool but the single person who understands it.

Keep a written runbook for every workbook that survives the first cull, even the ones staying for another year.

Ask what happens when that person goes on leave. The answer is usually a fortnight of silence.

Governance and Change Control

A low code app can be changed in an afternoon, and that is both the benefit and the risk.

Without separate environments, a change made on Friday can break the month-end approval on Monday.

low code software development in Kenya should separate development, testing and production, even when the platform makes it easy to skip.

Every change needs a request, a reason, a tester and a release note. The form can be small, but it must exist.

Batch changes into a weekly window. Continuous deployment suits a product team, not a finance department in its close.

Freeze changes for the last three working days of the month. A release during close turns a small bug into a reconciliation problem.

low code software development in Kenya should record who approved the change and what was tested, because that is the first question after an incident.

Version control is thinner in low code, so name releases and keep the export file.

low code software development in Kenya should restrict production access to a small group, with a named deputy.

Segregation of duties matters more, not less, when the builder is also the process owner.

Keep a change calendar visible to the business, so nobody schedules a release on the day of a stock take.

Review changes monthly with the business, and publish a short list of what went live.

When Custom Code Becomes Cheaper

Custom code wins when the logic is the product, when volume is high, or when the interface is the differentiator.

A pricing engine with a hundred rules, a routing algorithm or a real-time integration deserves a codebase and a test suite.

So does anything a regulator will inspect line by line, because the evidence has to be reproducible years later.

low code software development in Kenya should compare the annual licence with the cost of two developers and an environment.

Custom code is not cheaper on day one. It is cheaper in year three if the process is stable and the volume is large.

low code software development in Kenya should also weigh maintenance: a custom system needs a team, a roadmap and a security patch cycle.

The hybrid is often right: low code for the forms and the queue, custom code for the calculation and the integration.

low code software development in Kenya should define that boundary in writing, with data contracts between the two parts.

Avoid rewriting a working app because the platform is unfashionable. Boredom is not a business case.

Revisit the decision when the user count doubles or the transaction volume triples.

Put the review date in the contract renewal diary, alongside the licence cost and the support fee.

Three-Year Total Cost

The licence is the smallest line in most low code business cases, and the easiest to quote.

Implementation, integration, training, support, governance and exit usually exceed it inside three years.

low code software development in Kenya should build the model with those lines visible, not buried inside a professional services estimate.

Integration is usually underestimated. M-PESA, eTIMS, the ERP and the bank each need mapping, testing and monitoring.

Add the cost of the people who will maintain those integrations, because the platform licence does not include them.

Count the test environments too. Teams that test in production pay for it in incidents rather than in licences.

low code software development in Kenya should include internal time: the process owner, the tester, the trainer and whoever answers questions.

Support is not optional. A business-critical app needs a rota, an escalation path and a named vendor contact.

Price the premium support tier once. The difference between a four-hour and a four-day response is a real number.

Add contingency for year two, when the first app has grown and the champion has moved.

Compare the total with the process cost today: hours, errors, rework and the delay in closing the books.

A business case that counts only licences is a quotation, not a case.

Ask the finance manager to sign the assumptions, not only the total. The assumptions are what the board will question in year two.

Prototyping Without Committing

A two-week prototype answers more questions than a six-month business case.

Pick one process, use real data, and put it in front of the people who will use it every day.

Record the session. What users say they need and what they do with the prototype are often two different requirements.

Keep a list of what the prototype deliberately ignores. It becomes the scope document if the project proceeds.

low code software development in Kenya should set exit criteria before the build: can a clerk finish the task in three minutes without help.

Prototype the awkward part. If the approval chain has a delegate and a returning officer, build that, not the happy path.

low code software development in Kenya should be tested on the phones staff actually carry, on the network the branch actually has.

A prototype is not a pilot. Do not put it into production because it worked in the meeting.

Give the prototype an expiry date and delete it, or it becomes the system of record by accident.

low code software development in Kenya should document what the prototype proved and what it did not, with a decision date.

Kill the idea early if the fit is poor. That is a successful prototype, not a failure.

The output is a decision, not a demonstration.

Approvals, Audit and the Finance Sign-Off

Finance cares about three things in any new system: who approved, what changed, and where the evidence sits.

A workflow that sends a message and waits for a thumbs-up fails all three.

low code software development in Kenya should capture the approver, the timestamp and the document, in a sequence that cannot be reordered.

Delegation is normal in Kenyan organisations during leave and travel. Delegation must expire, and the delegate must be named.

Test the delegation path while the approver is still in the office. A broken chain discovered in December is expensive.

low code software development in Kenya should show the pending queue by approver, with an age in days, so nothing waits silently.

The auditor will ask for a report of all approvals above a threshold. That report should exist before the request arrives.

low code software development in Kenya should keep the history immutable, including rejected requests and their reasons.

Sign-off by finance should be a step in the process, not an email after the fact.

Report approval cycle time monthly. A queue that takes nine days is a process problem before it is a software problem.

Name a single owner for the approval process, not a committee. Committees approve slowly and nobody is accountable.

If the platform cannot prove who approved what, it is not ready for money.

Vendor Lock-In in Practice

Lock-in is rarely a single clause. It accumulates through skills, integrations and the shape of the data.

The team learns the platform, the integrations are built to its model, and the data arrives in its format.

Ask what a migration would cost if the price doubled tomorrow. If the answer is unknown, the negotiation is already lost.

low code software development in Kenya should test the exit every year with a small export, not once at the end of the contract.

Proprietary scripting is the subtle version. Logic written in the platform’s own language rarely moves anywhere.

low code software development in Kenya should keep business rules in a documented table, so they can be re-implemented elsewhere.

Ask for the roadmap and the deprecation policy. A platform that retires features will eventually retire yours.

Negotiate a cap on renewal increases, or accept that the second negotiation is harder than the first.

A short contract with a clear exit beats a long contract with a discount.

Keep the source of any custom scripts in your own repository, even when the platform hosts the runtime.

The goal is not to leave. It is to be able to leave, which changes the conversation.

Skills, Handover and the Team You Keep

Every low code programme depends on two or three people, and one of them usually leaves.

The builder knows where the rules live, which is rarely where the documentation says.

low code software development in Kenya should require documentation as a deliverable: data model, rules, integrations and the support path.

Pair the builder with a second person from the business, and let that person release a small change alone.

Rotate that second person every year. Two trained users are resilience; one is a risk with a nice title.

low code software development in Kenya should train a platform administrator who is not the vendor, and give that person production access.

Handover is a rehearsal, not a document. Sit the new person in front of a live incident and watch.

low code software development in Kenya should keep a skills map with names against each app, reviewed every quarter.

Contractors are fine, but the knowledge should land inside the organisation.

A platform with one expert is a single point of failure with a subscription attached.

Write the handover into the job description, not into a goodbye email on the last Friday.

Integration Depth and the ERP Boundary

Low code is good at the edge and poor at the core. The ERP should remain the record for money and stock.

An app that holds its own customer list will disagree with the ERP within a month.

low code software development in Kenya should read master data from the ERP and write transactions back, not the other way round.

Idempotency matters. A retried webhook must not create a second payment or a second journal.

Use the source document number as the key. Two systems that agree on the key can usually agree on the record.

Replay one failed message by hand every month. It proves the error queue works before a real outage tests it.

low code software development in Kenya should log every payload, with a status, a retry count and an owner for failures.

Error queues need a screen, not an email inbox. Somebody should be able to see what is stuck.

low code software development in Kenya should define the contract: fields, formats, validation and behaviour on rejection.

Batch and real time are different problems. Choose deliberately, then document the schedule.

The boundary should be drawn in a diagram that a new developer can follow in ten minutes.

Review the diagram when the ERP is upgraded, because an interface that worked last year can fail on a version change.

Security Reviews and the ODPC

A low code app can hold personal data by lunchtime, and the obligations arrive with the first record.

Registration as a data controller, a lawful basis and a retention rule apply to the app, not only to the core system.

low code software development in Kenya should use single sign-on and multi-factor authentication, not a shared local password.

Guest access and public links are the usual leak. Review every shared link and expire the ones nobody needs.

Turn off anonymous access at the platform level, then allow exceptions with an owner and a date.

Log every export of personal data, including the ones staff do for a report. Exports leave the building more often than records do.

A data protection impact assessment should be recorded for anything touching health, finance or children.

Vendor assessment is part of the review: where the data sits, who can see it, and what happens on a breach.

low code software development in Kenya should test the restore and the deletion path before a regulator asks.

Roles should follow the process rather than the org chart, and they should change when someone changes desk.

A penetration test once a year is cheaper than the conversation after an incident.

Track the findings to closure, with a severity and a date. A report nobody actions is a filing exercise.

Scaling From One Department to a Group

The first app belongs to one department. The tenth belongs to a group with subsidiaries and a board.

At that point the questions change from features to standards, and the answers change the budget.

low code software development in Kenya should introduce a platform team, a design standard and a review board before the estate doubles.

Multi-entity data needs a clear rule: shared master data, separated transactions, consolidated reporting.

Decide early whether the group wants one tenant or several. Moving later is a migration, not a setting.

Agree which entity owns the contract and which entities consume it. Shared licences fail when a subsidiary is sold.

low code software development in Kenya should check the licence model across entities, because one subsidiary can change the bill.

Naming conventions, colours, error messages and approval patterns should be consistent across apps.

low code software development in Kenya should measure adoption by process, not by logins, or the dashboard will flatter the programme.

A centre of excellence is a cost until it starts retiring apps and reusing components.

Give it a target: five apps retired and three components reused in the first year, or the funding will be questioned.

Scale the governance with the estate, not far ahead of it.

The Decision Rule

The decision is not low code or custom code. It is which parts of a process deserve which tool.

Start with transaction volume, the number of decisions, the regulatory exposure and the expected life of the process.

Score the process against the platform shortlist. A tool that fits nine processes out of ten is still a tool with a gap.

low code software development in Kenya should be chosen for forms, queues, checklists and approvals that change every quarter.

Choose custom code for pricing, statutory calculations, high-volume processing and anything that is the product itself.

low code software development in Kenya should keep the integration layer explicit, whatever the tool, so the boundary survives a platform change.

Price the three-year total, including exit, and compare it with the process cost today.

low code software development in Kenya should pilot with real users and a decision date, then retire whatever does not earn its place.

Governance is the difference between a platform and a pile of apps.

Review the estate every year against that rule, and be willing to close what no longer earns its place.

The best outcome is a small estate that people trust, not a large one nobody can explain.

Leave a Reply

Your email address will not be published. Required fields are marked *