A deliberately boring technology stack, chosen so your software still works in ten years

Python and Django

Python is our primary language and Django is our primary framework. Django arrives with security defaults already in place, an administration interface that saves months of work, a mature migration system for evolving databases safely, and a user and permission model that suits almost every business system we are asked to build.

The practical benefit is that we spend our hours on the part that is specific to your company rather than rebuilding foundations that every application needs. The strategic benefit is that Django has been maintained for many years by a large community with a published release and support policy, so an application written today has a documented path forward for a long time.

Django REST Framework sits alongside it for interfaces, giving us serialisation, authentication, permissions, throttling and browsable documentation without inventing anything unusual that a future developer would have to decode.

MySQL, Redis and Celery

MySQL holds the data that must never be lost. We design schemas properly, use foreign keys and constraints rather than hoping the application layer behaves, add indexes based on the queries the system will actually run, and plan for the volume the table will hold in five years rather than five weeks.

Redis handles caching and session storage, which is usually the fastest single improvement available to a slow application. Expensive queries and rarely changing pages get cached with sensible expiry rules, and the difference on a busy system is measured in whole seconds.

Celery runs the work that should never block a page. Sending thousands of notifications, producing large reports, processing uploads, calling slow external services and running scheduled nightly tasks all happen in background workers. The user clicks a button, gets an immediate response, and the heavy lifting happens where nobody is waiting.

Kotlin, SwiftUI and Firebase

Mobile applications are written natively. Kotlin for Android and SwiftUI for iOS give us applications that feel correct on each platform, start quickly, behave well on older hardware and respect battery and mobile data. Users notice the difference even when they cannot explain it.

Both applications talk to the same REST API, which means one set of business rules rather than three implementations that slowly drift apart. Firebase Cloud Messaging delivers push notifications reliably to both platforms without us building notification infrastructure from scratch.

We also handle everything around the code, including store listings, screenshots, privacy declarations, review responses, staged rollouts and the ongoing obligation to keep published applications compatible as each platform raises its requirements.

Linux, NGINX and Gunicorn

Production applications run on Linux servers we configure ourselves. NGINX sits at the front handling connections, static files, compression and certificates. Gunicorn runs the Django application behind it with a worker count matched to the machine. Systemd keeps services running and restarts them if they fail.

Around that core sits everything that separates a real deployment from a hopeful one, such as firewall rules, automatic certificate renewal, log rotation, fail counting on login attempts, scheduled offsite backups and monitoring that alerts us rather than your customers when something stops responding.

We can deploy to a virtual private server, to a cloud provider or to infrastructure you already own. What we insist on is that the configuration is documented and reproducible, so rebuilding the environment is a known procedure rather than an archaeology project.

Artificial intelligence platforms

We integrate large language models into production applications using platforms including Claude and DeepSeek. The model is the easy part. The work that matters is everything around it, including giving the model access to the right internal data, constraining what it is allowed to do, handling the cases where it is uncertain, logging what it produced and making sure a human can step in.

We build assistants that answer questions from your own documents, classifiers that route incoming work, drafting tools for repetitive correspondence and agents that carry out defined multi step tasks inside your system. We are equally willing to tell you when a simple rule would do the job better and cheaper than a model.

Front end and integration

On the browser side we favour clean HTML, modern CSS and the amount of JavaScript the job genuinely needs. Bootstrap gives us a responsive grid and accessible components without a heavy build pipeline, which keeps pages fast and keeps the code readable by whoever inherits it. Where an interface truly requires a rich client, we build one, but we do not impose that complexity on a site that does not need it.

Integration work covers payment providers, email delivery services, SMS gateways, accounting packages, mapping and location services, calendar systems, document storage and any documented third party API. If a system you rely on offers an interface, we can usually connect it to the software we build.