Apache Fineract upgrades and support

A live Fineract core banking system needs a planned path from one quarterly release to the next. This page covers what upgrade and support work includes, what drives its cost, and what you provide and receive.

On this page

Why Apache Fineract upgrades and support need a plan after go-live

Upgrades and support for Apache Fineract are ongoing work that needs a named owner from the day the platform goes live. The project publishes official releases quarterly, at the end of each quarter, so the platform changes whether or not the bank is ready for the change. Many institutions split the work between an internal platform team, which owns the environments, access and day-to-day operations, and an outside partner that plans and executes upgrades, fixes and specialist changes. The decision to make is not whether the work happens, but who performs each part and how the handoff is documented. The work is triggered by more than the calendar. A new quarterly release is the obvious one, but a security fix published against a version in use, a new loan or savings product, a move to a newer PostgreSQL version or a newer Kubernetes platform, and staff turnover in the team that holds the deployment knowledge all create the same need to re-validate the system. Fineract also changes its database schema through Liquibase migrations, so even a configuration change can have upgrade consequences. Before go-live, the owner should write down which of these triggers apply and who decides on each one.

Fineract is headless. It exposes REST APIs and does not provide its own user interface, and the project points to the Mifos X web application as the front end used in its Kubernetes example. That means the bank's own front end, its channel applications, and every integration that calls the APIs or consumes business events must be checked on each upgrade, not just the core. An API response field that changes, an authentication flow that is adjusted, or an event payload that is altered can break a system that never appears in the Fineract release notes. The owner should keep an inventory of every API consumer, its version and its test coverage, so that the regression scope for each release is known in advance. The Fineract README warns that a production deployment can be complex, costly and time-consuming, and it states that the project does not provide a comprehensive production deployment guide. It also notes that organizations may pay a vendor for deployment and maintenance. The practical consequence is that operating knowledge, including how the read, write and batch instances are arranged, how migrations are sequenced, how Close of Business is monitored and how backups are restored, sits with the deploying organization or its partner. A support agreement should therefore name who holds that knowledge in writing, and the bank should confirm that its internal team can operate the platform without relying on the people who built it. Before signing any support arrangement, ask the prospective partner to describe how it would handle a quarterly release, an out-of-cycle security fix and a failed migration on a live instance. Ask which environments it would test in, who approves the change, how a rollback would work and what evidence the bank would receive afterward. Confirm which Fineract version the bank currently runs and which release it expects to track, and check the Fineract website and documentation for the latest stable release and end-of-life notices before the plan is written. These answers determine the scope of any retainer and make the ongoing cost visible.

What Apache Fineract upgrades and support work includes

An upgrade or support engagement is a set of work packages that move a live Fineract deployment from one stable release to the next without disturbing loan, savings and accounting behavior. Each card below is a distinct package, and scope, deliverables and timelines are agreed in writing before work starts, with ongoing support available as a retainer.

Release review and impact assessment

Each quarterly Fineract release is compared against the deployed version so the team knows which changes touch APIs, database schema, configuration, authentication or batch behavior. The current stable line at the time of writing is 1.15.0, and the release notes should be confirmed on the day of review. The output is a written impact list that drives the rest of the plan.

Staging upgrade and Liquibase migrations

The upgrade is rehearsed on a staging copy of production data, with Liquibase schema migrations run on the write instance, since migrations only execute there. Teams should confirm the migration duration on realistic data volumes and check that the batch and read instances are restarted in the right order. Findings feed back into the production runbook.

Regression testing of products and accounting

Test scripts cover configured loan and savings products, interest and fee calculations, repayment schedules and the journal entries each transaction posts to the ledger. Results are compared against the pre-upgrade baseline so that any change in balances or postings is explained before cutover. Finance should sign off on the accounting results, not only the technical pass or fail.

Batch and read instance checks

The Close of Business Day batch job, the batch instance and the read instances are verified against the new version. For deployments with large account volumes, the run time and any remote partitioning workers are measured because the job can run for hours. Read instances on database replicas are checked for consistency after the write instance has migrated.

Security configuration review

Each release is checked for changes that affect the security baseline, including default development credentials, OAuth2 or basic authentication settings, and HTTPS configuration through the SSL environment variables. The aim is to confirm that the default login has been replaced and that HTTPS-only access still holds after the upgrade. Findings are recorded as configuration changes with owners and dates.

Monitoring, runbooks and production cutover

Dashboards, alerts and runbooks are updated for new endpoints, log formats and batch metrics introduced by the release. The production cutover follows a written plan with a rollback plan that names the conditions for reverting and the steps to restore the prior version and database state. Teams should confirm backup and restore timings before the change window is booked.

What drives Apache Fineract upgrade and support effort

This table lists the factors that change how much work each Fineract upgrade and each year of support takes, why each one matters, and what to do to keep it under control. Read each row as a question to answer about your own deployment before you ask a partner for a quote.

DriverWhy it changes effortHow to keep it down
Product types and custom business rulesEvery configured loan and savings product, fee, charge and delinquency rule is a regression test case after each release. Custom rules that sit in code also need rework when core behavior changes.Keep products to a documented catalog, prefer configuration over code, and maintain a product test matrix that runs after each upgrade.
Integrations and external event consumersEach system that reads Fineract APIs or consumes ActiveMQ or Kafka events depends on payload and endpoint behavior that can shift between releases.Publish an interface inventory with owners, pin contract tests for each consumer, and version any custom event payloads.
Database size and number of accountsLarger databases lengthen Liquibase migrations, backups, restores and checks. At millions of accounts the Close of Business Day batch job can run for hours, so upgrade rehearsals take longer.Measure migration and batch run times on a production-sized copy, plan partitioning early, and schedule upgrades around the batch window.
Custom modules and API extensions outside core codeCode that lives outside the core repository must be rebased, rebuilt and retested for every target release. Extensions that touch internal classes break more often.Keep customizations in separate modules, limit use of internal APIs, and record which extension depends on which core version.
Number of environments and distance from productionEach environment needs its own upgrade run, data refresh and test pass. Environments that differ from production hide problems until the production upgrade.Keep a minimum set of environments that mirror production configuration, refresh data on a schedule, and promote the same artifacts through each stage.
Number of tenants on one platformMigrations and configuration changes apply per tenant, and a fault can affect several institutions or brands at once. Test cases multiply with each tenant's products.Standardize tenant configuration, record per-tenant differences, and stage tenant upgrades so one institution is updated and verified before the next.
Hosting model (Kubernetes, VMs or air-gapped)Kubernetes allows the separate liquibase-only run and rolling deployments. VM and air-gapped setups need manual steps, offline image and dependency transfer, and more hands-on verification.Document the exact deployment procedure for your model, automate image promotion where the network allows, and confirm the upgrade steps with your own platform team.
Versions skipped between current and target releaseFineract ships official releases quarterly, so a deployment far behind the current line must cross more schema changes, deprecations and configuration changes in one step.Upgrade on a regular cadence, read the release notes for each intermediate version, and confirm the supported upgrade path with the project before planning the move.
Compliance evidence for each changeChange records, test results, reconciliation outputs and approvals must be retained for each release. Assessors and internal audit expect the same evidence for every change, so the effort repeats each time.Template the change record, automate test evidence capture, keep reconciliation reports with the release ticket, and agree the retention period with your compliance team.

How a Fineract upgrade runs from release review to go-live

The sequence turns a new Fineract release into a tested, reversible change to your production instances, with a documented handover at the end. Each phase closes with a written output that the next phase depends on, so the change is decided on evidence rather than on the release date alone.

  1. Review the release and assess impact

    We read the release notes for the target 1.x version against your current deployment, including your custom code, enabled features, configured products, database version and any external event publishing. Official Fineract releases are created quarterly, so the review also confirms which release is the right target and whether the one you run is still supported. The output is a written impact assessment listing each change that touches your products, accounting, integrations or configuration, with an owner and a decision for each item. You know this step is done when your team has signed off the list and the target version is agreed in writing.

  2. Confirm environment parity and backups

    We compare staging against production on Fineract version, PostgreSQL version, instance layout (read, write and batch), configuration variables, tenant setup and the size of the data set, because a staging test only predicts production when the two match. We then take a backup of the production database and restore it to a separate environment to confirm the backup is complete and usable. The output is a parity record showing where staging differs from production and why, plus a restore test result. The step closes when the restore is verified and every known difference is accepted or removed.

  3. Run the upgrade in staging with Liquibase

    We deploy the target release to staging and run the database migrations on the write instance, since Liquibase migrations run only on write instances. On Kubernetes, the migration can run as a separate job using the liquibase-only Spring profile, which keeps schema changes out of the normal application start. We record the migration time, any errors or warnings, and the state of each read and batch instance after the change. The output is a staging upgrade log and a list of configuration changes the production run must include. This step is done when the migration completes cleanly on a copy of production data and the services start against the new schema.

  4. Regression test products, accounting and batch

    We run regression tests against the upgraded staging environment covering loan and savings product behavior, repayment schedules, fees and charges, journal entries and ledger balances, and the Close of Business Day batch job. The test cases come from your configured products and your month-end reports, so the results reflect your institution rather than a generic script. Any difference from the pre-upgrade baseline is logged, classified as expected or defective, and either fixed or formally accepted. The output is a regression report with pass and fail results and a sign-off from your finance and operations leads. You know it is done when accounting totals reconcile to the baseline for the test data set.

  5. Review security and configuration

    Before production, we review the upgraded configuration against your security baseline, including whether default development credentials have been replaced, HTTPS is enforced, tenant and database access is restricted, and API authentication is set as agreed. We also check that release changes have not reopened settings you had closed, such as authentication defaults or exposed endpoints. The output is a configuration review with each finding marked resolved, accepted with a reason, or blocking. This step closes when no blocking finding remains and your security owner has accepted the residual items in writing.

  6. Execute the production change with rollback

    We carry out the production change in a window agreed with your operations team, following the tested staging runbook step by step. Before the change starts, the rollback plan is written and rehearsed, with the backup point, the conditions that trigger rollback, and the person who makes that call. The output is a completed change record with the migration result, smoke test results and the time each stage finished. If a blocking failure occurs, the rollback plan is executed and the change record shows what was restored. The step is done when the smoke tests pass on the write, read and batch instances and your operations team confirms the platform is in service.

  7. Monitor after go-live and hand over

    We monitor the upgraded platform for an agreed period after go-live, watching batch job duration, error rates, database load, event publishing and the first full business day's accounting run. Any issue found is triaged against the regression report and the rollback plan, so the team knows whether it is a defect, a configuration gap or an expected change. We then hand over the runbook, the updated configuration record, the test evidence and the open items to your team or to the support agreement. The output is a handover pack and a closed change record. The step is complete when your operations owner accepts the handover in writing.

How regression testing protects loan, savings and accounting after an upgrade

Regression testing matters more than the migration itself because a Liquibase schema change can finish cleanly while the behavior of the bank's products shifts underneath it. A database that migrates without errors tells you the tables are in the right shape. It does not tell you that interest accrual still rounds the way your loan contracts require, that a late fee still posts on the due date, that a delinquency bucket still moves an account at the right point, or that a savings interest run still credits the correct ledger account. Those behaviors live in application code and configuration, and each Fineract release can change them. The migration step is the easy part to verify. The test set is what tells you whether the institution can keep operating the next morning.

The most useful test set is built from your own products, not from generic Fineract demo data. Start with a fixed list of loan and savings scenarios drawn from the products you actually run: a standard amortizing loan with a grace period, a loan with a balloon payment, a loan that goes into arrears and is restructured, a fixed deposit that matures, a recurring deposit with a missed installment, and a savings account with a withdrawal fee. For each scenario, record the expected repayment schedule, the expected balances at defined dates, and the expected fee and interest postings before the upgrade is applied. Store those expected results alongside the scenarios so a difference is visible rather than discovered later by a customer or a reviewer. Add journal entry checks that confirm each posting maps to the right account in your chart of accounts, and run a Close of Business Day job on a production-sized copy of the database so that batch behavior and timing are tested against realistic volume.

Reconciliation closes the loop. Before the upgrade, capture ledger totals by account and by product for a defined period, and after the upgrade on the same copy, repeat the capture and compare. Any difference, including a difference in rounding or a shift between two accounts that nets to zero, needs an explanation signed off by finance before the release moves forward. Ask your implementation partner or internal team to show the reconciliation output, not only a pass or fail flag, so that finance can read the actual movements. Confirm with the partner how the test harness will be run and who owns the sign-off at each step.

Test data handling needs a decision early. If the production-sized copy contains client records, identity details, or KYC documents, those fields must be masked or replaced with synthetic values before the copy reaches a test environment that more people can access. Masking should preserve the characteristics the tests depend on, such as account status, product type, balance ranges and date patterns, while removing personal identifiers. Confirm the masking approach with your data protection and information security owners, and record which environments hold masked copies and who may access them. Masking the data also keeps the test environment within the same access controls you apply to the rest of the core banking estate.

The test set should live in version control, with the scenarios, expected results, journal checks, reconciliation scripts and configuration needed to run them. Storing it this way means the same suite runs against each quarterly Fineract release, and changes to expected results are reviewed like code changes instead of being edited quietly in a spreadsheet. Fineract publishes its releases quarterly, so a stable, reusable suite lowers the effort of each cycle. Ask for the suite to be delivered as part of the engagement, with documented steps for running it, a named owner for updating expected results when a product rule is deliberately changed, and a clear record of which release each result set was produced against.

Which Fineract upgrade and support tasks teams keep in-house and which they outsource

This table compares nine upgrade and support tasks and shows who usually carries each one, along with the skills each task demands. Read the in-house and outsourced columns together, because many tasks are split between the bank and a partner. In most banks, product ownership, approval and business sign-off stay internal, while partners often run the technical upgrade and testing work.

TaskUsually kept in-houseUsually outsourcedSkills required
Release monitoring and triageDeciding which quarterly release matters for the bank's products, regulations and open defectsReviewing release notes against the bank's custom code, modules and configuration, and flagging breaking changesJava and Spring, Fineract internals, banking product knowledge
Staging upgrade and Liquibase runApproving the target version and scheduling the staging windowRunning the upgrade on a staging copy, executing Liquibase migrations on the write instance and recording the resultsJava and Spring, PostgreSQL administration, Kubernetes, Liquibase
Regression test designDefining which loan, savings and accounting outcomes must not changeTranslating those outcomes into repeatable test cases covering products, fees, batch and ledger postingsBanking product knowledge, test design, Fineract API knowledge
Regression test executionReviewing failures and deciding whether a difference is acceptableRunning automated suites, triaging failures and reporting reproducible defectsTest automation, REST API testing, scripting
Batch and PostgreSQL operationsSetting the Close of Business window and accepting the operating impactTuning batch jobs, checking partitioning across workers, monitoring database load and replicasPostgreSQL administration, Spring Batch, ActiveMQ or Kafka, observability tooling
Security patch handlingApproving patch timing and any change to default credentials, access or exposureAssessing advisories, applying patches to the build, and re-testing authentication and HTTPS settingsJava dependency management, application security, identity and TLS configuration
Integration and event consumer updatesOwning payment, CRM, notification and reporting systems that consume eventsChecking event payload changes, updating Kafka or ActiveMQ consumers and replaying test eventsKafka or JMS messaging, integration design, API versioning
Change approval and audit evidenceRunning the change board, signing off, and keeping evidence for internal audit and regulatorsPreparing test results, deployment logs, rollback records and configuration diffs for the change fileChange management, audit documentation, familiarity with the bank's control framework
On-call supportIncident ownership, customer communication and regulatory reporting decisionsSecond-line diagnosis of Fineract, database and batch faults, with defined response expectations in the agreementLinux operations, Kubernetes, PostgreSQL, Fineract logs and troubleshooting

What usually goes wrong when Fineract upgrades are run without a plan

Most Fineract upgrade problems do not come from the release itself. They come from skipped test environments, unsafe migration steps, leftover defaults, scheduling collisions, custom code that drifted from core, and a deployment that is treated as finished before the books are checked. Each card below names one of these failure points and the check that prevents it.

Testing directly against production data

Teams that skip staging and apply a new Fineract release straight to production have no safe place to see how existing loan and savings products behave on the new code. Keep a non-production environment restored from a recent production backup, and run the upgrade there first. Confirm that the backup restores cleanly and that the upgrade rehearsal is timed and repeatable before any production change is scheduled.

Running Liquibase from several instances

Fineract database migrations run only on write instances, so starting the upgraded application on every node at once can cause competing schema changes against the same PostgreSQL database. Designate one write instance, run the Liquibase migration there, or use the separate liquibase-only Spring profile on Kubernetes, and only then bring other instances online. Check the instance type settings on each node before starting it.

Leaving the default development login in place

The Fineract README documents a default development login of mifos with a password that must be changed for any real deployment. Upgrades often recreate environments from scripts or images, and a default account can quietly return with them. Before go-live and again after every upgrade, confirm that the default credentials are disabled or changed, and that OAuth2 or basic authentication settings match the intended configuration.

Overlapping Close of Business with a release

The Close of Business Day Spring Batch job can run for several hours on deployments with millions of accounts. A release window that touches the database, the batch instance or its worker nodes while this job runs can leave partial postings or failed partitions. Set the release calendar against the batch schedule, confirm the job has completed successfully on the last business day, and check its status before and after the change.

Custom code drifting from core

Local modules, reports and API extensions that were written against internal classes or altered core files often break on the next release, sometimes without a compile error. Keep customizations in separate modules that depend only on documented interfaces, and keep a record of every core change. Before each upgrade, build the custom code against the target release and run its tests, so breakage is found in the branch rather than in the production window.

Falling behind the release cadence

Fineract publishes official releases quarterly, and end-of-life releases are archived. An institution that waits several cycles can find that its version has no maintained path, and each skipped release makes the next migration larger and riskier. Agree on a supported version policy, decide how many releases behind is acceptable, and schedule regular upgrade rehearsals so the team keeps the ability to move quickly.

Treating deployment success as a balanced ledger

A deployment can start, pass health checks and serve API calls while product-to-ledger mappings, accrual postings or interest runs produce wrong balances. Success should be defined by evidence: trial balance comparisons before and after the upgrade, sample loan and savings account reconciliations, and finance sign-off on the accounting outcome. Without that, errors surface weeks later in month-end close.

What recurring upgrade and support costs look like after go-live

The Apache License 2.0 that covers Apache Fineract carries no license fee, so the recurring cost of running Fineract is the cost of operating it. That bill has several parts, and each one should appear as its own line in a quote. The first is hosting: compute for the write, batch and read instances, the PostgreSQL database and its read replicas, storage, backups and network. The second is a front end if you use one. The Fineract README points to the Mifos X web application in its Kubernetes example, but Fineract itself is headless, so whichever interface your staff use carries its own hosting, patching and release work. The third is monitoring and backup, which need someone to own alert thresholds, restore tests and retention rules.

Staff time is usually the largest recurring item and the easiest to underestimate. Fineract publishes official releases quarterly, at the end of each quarter, so each cycle needs someone to read the release notes, assess the impact on your custom modules and integrations, run the regression suite over loan and savings products and accounting postings, and schedule a window for the Liquibase migrations, which run only on the write instance. Security patch handling adds unplanned work between cycles. Ask who performs each of these tasks, whether they are your staff or the partner's, and how many cycles per year the quote covers.

Some costs are one-time and should be separated from the ongoing figure. Initial hardening, the regression test set, the runbooks for migrations, batch restarts and tenant onboarding, and the first round of monitoring setup are normally delivered once during implementation. They recur only when the platform changes materially. Everything else recurs: each quarterly release cycle, environment maintenance such as keeping staging close to production, certificate and credential rotation, and support hours. A quote should state which items are one-time, which are monthly or annual, and the rate or allocation for each.

Cost rises with the number of tenants, integrations, custom modules and environments. Each additional tenant adds configuration to test and tenant-specific data to verify after a migration. Each integration, such as an external event consumer on Kafka or ActiveMQ, needs regression checks whenever Fineract or the consumer changes. Custom modules must be re-tested against each release, and every extra environment has to be patched and kept in step with the others. Ask the vendor how each of these factors changes the support allocation, and whether the quote includes a defined number of environments.

Before you sign, require the quote to list every component above, the release cycles it covers, and the support hours and response expectations in writing. Response expectations should name the severity levels, the time to first response for each, what counts as business hours in your time zone, and who approves emergency out-of-hours work. Also confirm whether you can choose between a support retainer and internal on-call coverage, and what each option leaves to your team. Illustrative example: a quote that lists quarterly cycles and a fixed monthly support allocation but omits environment maintenance has left one of the largest recurring costs unpriced.

How upgrade and support work changes by starting point and hosting model

An instance that has run for years usually carries two kinds of drift: releases missed since it was installed, and custom code written against internals that have since changed. The plan starts with a gap analysis that maps every release between your current version and the target, so each stop on the upgrade path has a known purpose.

  • Release path: list each intermediate release, its migration notes and the Liquibase changesets that will run on the write instance. Test at each stop when the instance is more than one step behind the target.
  • Custom code inventory: check each custom module, API extension, report and business rule against the target release. Flag anything that touched core classes for rework.
  • Configuration review: export product definitions, accounting mappings and scheduled jobs, then compare them with the target release's behavior.
  • Rollback points: take a restorable database snapshot before each stage and test the restore procedure.

Check: ask for the release-by-release path with the migration notes your team must read, and confirm which custom changes sit outside core code.

What the client needs to provide before an upgrade or support agreement starts

Before an upgrade or support agreement starts, the bank has to hand over the working materials that make a Fineract change safe to plan. The first item is access to the current deployment and its configuration: the environment variables that set instance types (read, write and batch), the tenant settings, the database connection details and the SSL settings. Share access through the bank's own secrets manager or a controlled session rather than in written documents, emails or tickets. Credentials that the platform still ships with, including the default development login, should be listed as a finding to close, not carried forward.

Next, the bank provides the database backup and restore procedure, with the people who can run it and the last date it was tested. Liquibase migrations run only on the write instance, so the team needs to know how the existing schema history is stored and how the bank would roll back a failed migration. Alongside that, provide a current inventory of loan and savings products, accounting mappings from products to the general ledger, integrations, and every external event consumer that listens to Fineract business events on ActiveMQ, JMS or Kafka. Custom code repositories, build pipelines and the artifacts they produce should be included, with the owner of each.

The bank also needs a staging environment that behaves like production. For regression testing of products and accounting, the closer the data volume and account mix match production, the more useful the results. Where real customer data cannot leave production controls, ask for a masked copy and confirm which fields are masked, since masking can change interest, schedule and posting outcomes. Name the business sign-off contact for each product and for the accounting mappings, because a regression pass is only meaningful when someone in finance or product can say the output is correct.

Some items are decisions rather than documents. The bank must choose the target Fineract release (the project publishes quarterly releases, and 1.15.0 is the current stable release at the time of writing, so confirm the status before you commit). It must also set the upgrade window, name who approves each change, define support hours and the escalation path, and decide whether to keep an internal on-call rota alongside any vendor cover. Security and audit evidence requirements belong on this list too: confirm with your auditors which change records, test results and access logs they expect, and in what format, before the first upgrade is run.

Questions buyers ask about Apache Fineract upgrades and support

How often does Apache Fineract release new versions?

Official Apache Fineract releases are created quarterly, at the end of each quarter, following the Apache Software Foundation release policy, according to the project README. That cadence sets your planning rhythm. A release arriving every quarter means your bank will regularly face the question of whether to adopt it, when to test it and how much change it brings to loan products, accounting and integrations. Ask your team to decide in advance how many releases it can assess each year, who signs off on adoption, and how long a test cycle needs to be. The project also archives end-of-life releases, so a version you stay on too long will eventually stop receiving project maintenance. Build the upgrade calendar around the quarterly rhythm instead of reacting to each release on its own.

Can our bank upgrade Fineract in-house or do we need a partner?

Yes, your bank can upgrade Fineract in-house if its team has working skills in Java, PostgreSQL and Kubernetes and has tested upgrade processes it follows each time. A partner can cover the gaps, such as a missing skill, a thin test team or a one-off upgrade during a busy period. The deciding factors are less about the platform and more about your change process: a staging environment that resembles production, a rollback plan, a regression suite covering loan and savings products and accounting, and named people who approve the result. Ask an outside team which of these you lack today. Ongoing upgrades can be handled under a retainer, while a single upgrade is usually scoped as a fixed piece of work with the scope agreed in writing before it starts.

Why must Liquibase migrations run on the write instance?

Liquibase database migrations run only on write instances, according to the Fineract documentation, so schema changes belong to the instance that owns writes. Running migrations on read or batch instances risks the database schema and the running application code falling out of step, which can cause failures that are hard to diagnose during an upgrade. On Kubernetes, the migration can run separately using the liquibase-only Spring profile, which lets your team control when schema changes happen relative to the rollout. Your upgrade runbook should name exactly which workload runs the migration, in what order the instances are restarted, and how to confirm the schema version before traffic returns. Confirm the exact behavior for the version you plan to adopt with the project documentation and your own staging tests before you change production.

How long does a Fineract upgrade take for a bank?

The duration depends on scope and drivers, so no fixed figure applies to every bank. The main drivers are the number of local customizations, extensions and integrations that must be retested, the volume of data and accounts in the database, how complete your automated regression coverage is, and how many environments the upgrade must pass through before production. Batch processing also matters, because the Close of Business Day job can run for several hours on deployments with millions of accounts, according to the project README, and that run must be validated after the upgrade. Ask for a written plan that breaks the work into assessment, environment preparation, migration rehearsal, regression testing, cutover and post-upgrade monitoring, with the assumptions and dependencies for each stage stated clearly.

What does a Fineract support agreement actually cover?

A support agreement usually covers triage of reported issues, handling of patches, work on release cycles, and response expectations as they are written into the contract. Read the definitions closely, because the important differences sit there: what counts as a severity level, how response times are measured, whether your custom code and integrations are in scope, and whether upgrades to new releases are included or billed separately. DeployOpen offers support, upgrades and continuous testing as retainers, and most engagements are fixed-scope with scope, deliverables and timelines agreed in writing before work starts. Ask any provider to show the response expectations in writing, to name who will test changes before they reach production, and to explain how it will handle a release that reaches end of life.

What must our bank provide before an upgrade or support engagement starts?

Your bank must provide the access and information the work depends on, and the readiness requirements agreed in your written scope will list them precisely. Typical items include access to development, staging and production-like environments, a recent copy of the database that can be used for rehearsals, current backups, documentation of every local customization and integration, and a named business owner for loan products and accounting. You will also need test cases that represent how the bank actually lends, saves and posts entries, because automated checks without business sign-off leave gaps. Agree on change windows and approval paths early. Most delays in upgrade work come from missing access, unclear ownership or unavailable test data rather than from the code itself.

What happens when our Fineract version reaches end of life?

The project archives end-of-life releases, so the version stops receiving maintenance from the project, and your bank should plan to move to a supported release before that point. Staying on an archived release means security fixes and defect corrections from the project will no longer arrive, which increases operational and compliance risk. Treat the end-of-life date for your current version as a planning milestone, and check the project documentation for the status of any version you run. The move itself is an upgrade, so it needs the same regression testing of loan products, accounting, batch jobs and integrations. Build the timeline so that the upgrade is complete with enough margin to handle issues, not as a last-minute task.

Which regression tests matter most after a Fineract upgrade?

Test the areas where a bank's money and records move, then compare the results with a baseline captured before the upgrade. The priority list usually includes loan repayment schedules, interest calculation, fees and charges, savings posting and withdrawal rules, the Close of Business batch run, journal entries and the trial balance, and the reconciliation reports finance relies on. Also test every API call your integrations make, authentication with your chosen login method, tenant routing if you run several institutions on one platform, and any external business events your bank has enabled. Keep the tests repeatable, record the expected outputs with business sign-off, and rerun the full set after any fix. A suite that only checks that the application starts will miss the errors that matter most to finance and customers.

How DeployOpen scopes, delivers and supports Apache Fineract upgrades

DeployOpen plans, tests and documents Apache Fineract upgrades inside your own infrastructure, starting from a written scope that names the release, the instances and the products in play. Ongoing support can be run as a retainer, with each upgrade handled as a defined, reviewable piece of work.

How we scope

  • The written scope names the current and target Fineract release, the instances and databases involved, and the tenants affected.
  • We inventory custom modules, API extensions and configured loan and savings products so each one has a regression test.
  • The scope states whether the work is a one-off upgrade, a retainer for ongoing releases, or both, with deliverables agreed in writing before work starts.

How we build

  • We run the upgrade first in a non-production environment that mirrors your PostgreSQL version, instance layout and configuration.
  • Liquibase migrations are rehearsed on a write instance copy, since migrations run only on write instances and must be checked before cutover.
  • Regression testing covers loan and savings product behavior, accounting postings and Close of Business Day runs, with results recorded for your review.

How we hand over

  • Each upgrade comes with a runbook covering the sequence, rollback steps, configuration changes and verification checks.
  • Accounting reconciliation results and test evidence are delivered so your finance and risk teams can review what changed.
  • Your team receives documentation of customizations, environment variables and any settings changed from the Fineract defaults.

How we support

  • Support covers tracking quarterly Fineract releases and end-of-life notices so upgrades are planned before a version leaves support.
  • Retainer work can include applying upgrades, re-running regression tests and reviewing security settings such as default credentials and HTTPS.
  • Confirm response times, hours and escalation paths in the written agreement, since these are set per engagement and are not published.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.