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.
| Driver | Why it changes effort | How to keep it down |
|---|---|---|
| Product types and custom business rules | Every 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 consumers | Each 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 accounts | Larger 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 code | Code 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 production | Each 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 platform | Migrations 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 release | Fineract 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 change | Change 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.
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.
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.
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.
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.
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.
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.
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.
| Task | Usually kept in-house | Usually outsourced | Skills required |
|---|---|---|---|
| Release monitoring and triage | Deciding which quarterly release matters for the bank's products, regulations and open defects | Reviewing release notes against the bank's custom code, modules and configuration, and flagging breaking changes | Java and Spring, Fineract internals, banking product knowledge |
| Staging upgrade and Liquibase run | Approving the target version and scheduling the staging window | Running the upgrade on a staging copy, executing Liquibase migrations on the write instance and recording the results | Java and Spring, PostgreSQL administration, Kubernetes, Liquibase |
| Regression test design | Defining which loan, savings and accounting outcomes must not change | Translating those outcomes into repeatable test cases covering products, fees, batch and ledger postings | Banking product knowledge, test design, Fineract API knowledge |
| Regression test execution | Reviewing failures and deciding whether a difference is acceptable | Running automated suites, triaging failures and reporting reproducible defects | Test automation, REST API testing, scripting |
| Batch and PostgreSQL operations | Setting the Close of Business window and accepting the operating impact | Tuning batch jobs, checking partitioning across workers, monitoring database load and replicas | PostgreSQL administration, Spring Batch, ActiveMQ or Kafka, observability tooling |
| Security patch handling | Approving patch timing and any change to default credentials, access or exposure | Assessing advisories, applying patches to the build, and re-testing authentication and HTTPS settings | Java dependency management, application security, identity and TLS configuration |
| Integration and event consumer updates | Owning payment, CRM, notification and reporting systems that consume events | Checking event payload changes, updating Kafka or ActiveMQ consumers and replaying test events | Kafka or JMS messaging, integration design, API versioning |
| Change approval and audit evidence | Running the change board, signing off, and keeping evidence for internal audit and regulators | Preparing test results, deployment logs, rollback records and configuration diffs for the change file | Change management, audit documentation, familiarity with the bank's control framework |
| On-call support | Incident ownership, customer communication and regulatory reporting decisions | Second-line diagnosis of Fineract, database and batch faults, with defined response expectations in the agreement | Linux 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.
On Kubernetes, Liquibase migrations can run as a separate workload using the liquibase-only Spring profile. This lets schema changes be applied once, as a controlled job, before application workloads move to the new build. Because migrations run only on write instances, the plan has to fix the order of every rollout step.
- Separate migration job: run the liquibase-only profile as a one-off job with its own logs and an approval step before it starts.
- Rollout order: confirm the migration completes before read, write and batch deployments are updated.
- Mixed-version window: check the release notes for whether read and batch instances can run different versions during the change window.
- Environment parity: use the same image tag and configuration in staging and production, so the migration tested is the migration run.
- Chart or manifest changes: confirm how your Helm chart or manifests pass the profile and instance type variables to each workload.
Check: the rollback procedure for a failed migration job, and who approves that job before it runs in production.
Without an orchestrator, each step is run by hand or by your own automation, so the plan has to name every host, the order of stops and starts, and the person responsible for each command. The process is more manual, which makes the runbook and the evidence trail the main controls.
- Host inventory: list every write, batch and read instance with its database connections and the order they stop and start.
- Single migration host: Liquibase runs on the write instance only. The runbook must name that host and stop other hosts from starting the new build early.
- Configuration drift: environment variables that set instance type and SSL behavior must match what the runbook expects on each host. Compare them before and after the change.
- Step records: record each command, its output and a timestamp, because your team keeps the audit trail.
- Artifacts and drivers: pin the application artifact and JDBC driver versions. The official Docker image ships only the PostgreSQL driver, so confirm any other driver you need.
Check: whether your team has a tested runbook with a named owner for each host, and how long a full stop and start takes in your environment.
Without internet access, every release package, container image, build dependency and database driver must cross the boundary through a controlled transfer. The target build is then assembled inside the enclave from that bundle, so the transfer itself becomes a change-controlled step in the upgrade plan.
- Transfer manifest: list each artifact with its checksum and source, and have security approve the manifest before import.
- Offline dependency mirror: resolve build and runtime dependencies offline so the build can be reproduced inside the enclave.
- Image handling: load container images into the internal registry and record their digests.
- Migration bundle: send Liquibase changelogs and upgrade scripts in the same transfer as the application build, so they are tested together.
- Support access: confirm whether vendor updates and remote support sessions are possible. If they are not, the support and patch plan changes.
Check: the transfer cycle your security team accepts, and whether the enclave has a staging copy for regression tests before production.
On one platform, each institution is identified by the Fineract-Platform-TenantId header on API calls, and its database connection is configured from the tenants database. An upgrade changes shared code for every tenant at once, but each tenant holds its own data and may need its own upgrade sequence and test set.
- Tenant inventory: list each tenant with its database, custom configuration, enabled products and integrations.
- Wave plan: decide whether all tenants move in one window or in waves, and whether a pilot tenant goes first.
- Per-tenant test set: regression-test each tenant's products, accounting mappings and reports using that tenant's header and data.
- Shared services: changes to shared components, such as batch processing or event publishing, affect every tenant in the same window.
- Operating limits: confirm with the release notes and your own load tests how many tenants one platform can serve within your batch window.
Check: which tenants have different business rules, and who signs off each tenant's results before the next wave starts.
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.

