Skip to main content
Geecon Global

Professional services

Application development and maintenance, including what happens after launch

Building software is the smaller half. Most of an application's cost and nearly all of its life happen after go-live, which is the part most proposals skip.

Free consultationNDA on requestReply within one working day

Trusted by global clients and organisations

  • Cisco
  • Blackbaud
  • Compassion UK
  • Oracle
  • WSBC Bank
  • Essar
  • Port of Algoma
  • WSD
  • Headlines Advertising
  • T&S Heating
  • Marsham Court Hotel
  • Cubot
  • Equel
  • Fairhaven Healthcare
  • Great Step
  • FindUsOnWeb

The situation

The application nobody is responsible for

Software delivered without an owner degrades quietly. Dependencies age, small faults accumulate, and the people who understand it move on.

  • An application whose original developers have gone
  • Dependencies years out of date, some no longer supported
  • Faults reported by users rather than by monitoring
  • Small changes that take weeks because nobody dares touch it
  • No test suite, so every change is a risk
  • A supplier who built it and has since become unresponsive

What it covers

What this covers

  • New development

    Building applications, in increments, against requirements that are written down.

  • Taking on existing applications

    Adopting software somebody else built, including when documentation is thin and the original team has gone.

  • Support and incident response

    Agreed response times and a route to someone who can actually fix it rather than log it.

  • Updates and patching

    Keeping dependencies, frameworks and platforms current, which is the work that prevents an emergency later.

  • Ongoing improvement

    A steady flow of enhancement rather than a large project every three years.

  • Monitoring

    Knowing something is wrong before a user tells you.

How we work

How maintenance engagements start

Taking on unfamiliar software starts with understanding it. Anyone who quotes support on a codebase they have not read is guessing.

  1. 01

    Review the codebase

    Read what exists: structure, dependencies, test coverage, deployment, and the known problems.

  2. 02

    Stabilise

    Fix the urgent, get deployment reliable, and put monitoring in place so problems surface on their own.

  3. 03

    Reduce the risk

    Update dependencies, add tests where change is most frequent, and document what nobody wrote down.

  4. 04

    Improve steadily

    Move to a regular flow of enhancement, which is cheaper and less disruptive than periodic large projects.

Outcomes

What you are left with

  • A named team responsible for the application
  • Dependencies current, and a routine that keeps them current
  • Faults found by monitoring rather than reported by users
  • Tests where change is most frequent, so changes are safer
  • Documentation adequate for a new developer to start
  • Steady improvement instead of a large project every few years
Cloud architecture: regions, containers, scaling and managed data servicesUsersLoad balancerContainerContainerContainerManaged DBMonitoring

Platforms and tooling

What we work with

Platforms

  • .NET
  • Java
  • Node.js
  • Python
  • PHP
  • React
  • Angular

Operations

  • Azure
  • AWS
  • Docker
  • CI/CD
  • Monitoring

Practice

  • Automated testing
  • Static analysis
  • Dependency management
  • Documentation

Named as platforms we work with, not as formal partnerships.

Questions we are usually asked

Yes, and it is a large part of what we do. It starts with reading the codebase rather than quoting from a description, because the honest scope only becomes clear once you can see what is actually there.

Most inherited code is, to some degree. That is a starting point rather than a barrier: stabilise first, then reduce risk in the areas that change most often. Rewriting because the code is untidy is rarely justified on its own.

Usually a retained arrangement covering agreed response times and a volume of change, sized to the application. What matters is agreeing beforehand what counts as support and what counts as new development, because that boundary causes most disputes.

Yes, unfortunately. Dependencies acquire security vulnerabilities, platforms deprecate versions, and browsers change. An application left untouched for three years is not stable; it is accumulating an upgrade you will have to do all at once.

You should be able to. Code in your repositories, deployment in your accounts, documentation written for someone who has not met us. A supplier relying on lock-in rather than being worth keeping is a supplier you should be able to leave.

Yes. Adding capacity, covering a specialism, or taking a self-contained part of the estate are all common arrangements.

Talk to us

Talk to someone who has built this

Not a salesperson working from a form. Tell us what the problem looks like and someone who has delivered this kind of work will come back to you, usually within one working day.

Tell us what you need

No obligation, and nothing is shared outside Geecon Global.

Not sure where to start?

Fields marked * are required. We use your details only to reply to you. See our privacy policy.

Build smarter, scale faster