Kenya PAYE/NSSF/NHIF Payroll

Key Features

PAYE computed via a configurable graduated tax-band DocType (band floors, ceilings and rates as data, not hard-coded formula strings)

Personal relief plus optional insurance and pension relief applied automatically in the PAYE calculation

Tiered NSSF Act 2013 engine — Tier I and Tier II against pensionable-pay limits, with the employer match

SHIF deduction handling (successor to NHIF) with the current statutory rate and earnings base

Affordable Housing Levy (1.5%) computed on gross with matching employer contribution

KRA iTax P10 monthly return generated as an exportable ERPNext report / print format

Per-employee P9 form output for annual reconciliation and staff filing

Statutory rates managed in versioned config DocTypes so a Finance Act change is a data edit, not a code change

Server-side calculation via Python server scripts + hooks.py doc events on Salary Slip validate/on_submit (deterministic, browser-independent)

Works with native ERPNext Salary Structure, Salary Slip and Payroll Entry — bulk pay runs get statutory logic automatically

Whitelisted methods and the standard Frappe REST API expose results to downstream tools and integrations

Role profiles and DocType permissions scope payroll and statutory data to authorized roles only

Client scripts add in-form validation, computed helper fields and guardrails against misconfigured components

Scheduler events available for period-end reminders and draft payroll generation; built for Frappe/ERPNext v15 with a v16 upgrade path

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

You order

Start with a one-time build price. We scope it with you at kickoff.

We build & install

ECOSIRE builds, configures and installs it on your ERPNext.

Go live + support

You go live in about 2–4 weeks, with a post-launch support window.

About this Product

Running Kenyan payroll on stock ERPNext means fighting the Salary Structure engine every pay run. ERPNext core gives you a generic component/formula framework, but it does not ship the KRA PAYE tax bands, the tiered NSSF Act 2013 contribution logic, SHIF (the successor to NHIF) deductions, or the 1.5% Affordable Housing Levy — nor the P10 monthly return and per-employee P9 forms that KRA expects. Teams end up hand-coding fragile formula strings into Salary Component rows, re-editing them every time a rate or band changes, and reconciling statutory totals in spreadsheets outside the system. That is exactly where ERPNext native runs out of road.

We build a proper Frappe app (its own module, installed via bench get-app / bench install-app) that layers Kenya statutory logic onto ERPNext's existing Salary Structure, Salary Slip and Payroll Entry DocTypes rather than replacing them. Statutory rates live in versioned configuration DocTypes — PAYE band tables, NSSF Tier I/II limits, SHIF rate, personal and insurance relief — so when the Finance Act or a KRA notice changes a number, you edit a record instead of a formula string. The calculation runs through server-side logic (Python server scripts and hooks.py doc events on Salary Slip validate/on_submit) so PAYE, reliefs, NSSF, SHIF and Housing Levy are computed deterministically on the server, not in the browser, and applied consistently across single slips and bulk Payroll Entry runs.

Technically, the PAYE engine walks the graduated band table and applies personal relief and, where configured, insurance/pension relief; NSSF is computed as a tiered contribution against the pensionable-pay limits with the employer match; SHIF and the Housing Levy are applied as their respective percentages with the correct earnings base. Statutory returns are generated as ERPNext reports/print formats — a KRA iTax-ready P10 summary for the month and per-employee P9 forms — exportable for upload. Everything is exposed through the standard Frappe REST API and whitelisted methods so downstream tools (or your accountant's integrations) can pull results, and access is governed by role profiles and permissions so payroll data stays scoped to authorized roles. client scripts add the in-form validations and helper fields your team needs, and scheduler events can be wired for period-end reminders or draft-run generation. Built and tested against Frappe/ERPNext v15, with a v16 upgrade path.

Because this is build-to-order, nothing is a blind download. We start with a short scoping call to confirm your ERPNext version, pay elements, existing Salary Structures and which statutory outputs you file. ECOSIRE then builds your version of the app, validates it on a staging copy of your data with UAT and a rollback plan, installs it on your instance, and runs a training session before go-live. Typical delivery is 2-4 weeks from confirmed scope, and you receive the full git repository plus a post-go-live support window.

What you get

Installable source code for your version of the app (Frappe app installable via bench get-app / bench install-app)

Installation and configuration on your ERPNext instance, including statutory rate setup and Salary Structure wiring

Technical documentation — DocType schema, hooks.py doc events, server/client scripts, whitelisted API methods and config records

User guide plus a live training session for payroll and finance staff

UAT on a staging copy of your data with a documented rollback plan before production install

Post-go-live support window for fixes and configuration adjustments

Full git repository handover so you own and can extend the code

Statutory report templates (P10, P9) configured and validated against a sample pay run

Who this is for

East-African SME finance manager

Runs ERPNext for a Kenyan company and needs monthly PAYE, NSSF, SHIF and Housing Levy computed correctly inside payroll — without maintaining brittle Salary Component formulas or reconciling statutory totals in a separate spreadsheet.

Accountant / payroll bureau serving Kenyan clients

Processes payroll for multiple SMEs and files KRA returns. Needs reliable, auditable P10 and P9 outputs from ERPNext and configuration records that can be updated the moment KRA changes a rate or band.

ERPNext administrator / in-house developer

Owns the ERPNext instance and wants a clean, installable Frappe app — proper DocTypes, hooks and whitelisted methods, permissions and a git repo — rather than undocumented custom-field hacks they cannot maintain or upgrade.

HR lead at a growing Kenyan employer

Needs statutory deductions, employer contributions and employee P9 forms handled accurately and on time as headcount grows, with role-scoped access so payroll data stays confidential.

How Kenya PAYE/NSSF/NHIF Payroll Compares

Criterion	ECOSIRE	Custom Build	Competitor	ERPNext Native
Kenya statutory logic (PAYE/NSSF/SHIF/Housing Levy)	Built-in, tailored to your setup	You build and test every rule yourself	Generic, may lag KRA changes	Not included — hand-coded formulas only
P10 / P9 KRA reports	Configured and validated on a sample run	Build the report templates from scratch	Sometimes included, format varies	Not provided out of the box
Rate/band changes	Edit a config DocType, no code change	Depends on how you architected it	Wait for vendor update	Re-edit fragile formula strings
Fit to your instance	Scoped to your version and Salary Structures	Fully bespoke but on you to maintain	One-size-fits-all install	You configure everything manually
Code ownership	Full git repo handed over	You own it (and all its bugs)	Vendor-controlled, closed	N/A — no app
Delivery time	2-4 weeks from confirmed scope	Weeks to months of internal effort	Instant install, then integration work	Immediate, but incomplete for Kenya
Support after go-live	Included support window + training	Your team only	Tiered/paid support plans	Community forums
Server-side correctness	Deterministic server scripts + hooks.py events	Only if you build it that way	Varies by vendor quality	Formula strings, easy to misconfigure

Frequently Asked Questions about Kenya PAYE/NSSF/NHIF Payroll

Is this an instant download from the Frappe Cloud Marketplace?

No. This is a build-to-order engagement. ECOSIRE scopes, builds, installs and supports the app for your specific ERPNext instance and statutory setup. You are not buying an off-the-shelf download — you are commissioning a tailored Frappe app that we deliver as installable source plus a git repo.

How long does delivery take?

Typical delivery is 2-4 weeks from confirmed scope. Timing depends on your ERPNext version, the pay elements and Salary Structures already in place, and which statutory outputs you file. The scoping call establishes the exact timeline before any build starts.

How are statutory rate changes handled, and what about support and updates?

Statutory rates — PAYE bands, NSSF tiers, SHIF rate, reliefs and the Housing Levy percentage — live in configuration DocTypes, so most legislative changes are a data edit you can make yourself, not a code change. Your engagement includes a post-go-live support window for fixes and adjustments, and because you hold the git repo, we can also scope larger updates (for example, a KRA return-format change) as follow-on work.

Which Frappe/ERPNext versions are supported?

The app is built and tested against Frappe/ERPNext v15, with a supported upgrade path to v16. We confirm your exact version on the scoping call and build against it so the DocTypes, hooks and API methods line up with your instance.

Does it replace ERPNext's payroll, or extend it?

It extends it. The app builds on native ERPNext Salary Structure, Salary Slip and Payroll Entry rather than replacing them, adding Kenya statutory logic through server scripts and hooks.py doc events. Your existing payroll workflow, bulk Payroll Entry runs and reports keep working — the statutory calculations are applied automatically.

Can other systems read the payroll and statutory results?

Yes. Results are available through the standard Frappe REST API and whitelisted methods, so accountants' tools, dashboards or downstream integrations can pull PAYE, NSSF, SHIF, Housing Levy and P10/P9 data. Access is governed by role profiles and DocType permissions.

How do you protect our production data during the build?

We validate on a staging copy of your data with UAT and a documented rollback plan before touching production. Installation on your live instance happens only after sign-off, followed by a training session and the post-go-live support window.