Software that fits how you already work.

Most businesses don’t need a new idea. They need the thing they already do, done in software instead of in twelve spreadsheets and a WhatsApp group. That’s the work we’re best at: sitting with a process that grew organically, modelling it honestly, and replacing it with something that holds up under real use.

Applications we typically build

• Internal operations tools: job tracking, technician scheduling, inventory, service history. The kind of system that replaces a shared spreadsheet nobody trusts anymore.
• Client portals: where your customers check status, download documents, approve quotes and pay, without emailing anyone.
• Quoting & billing systems: pricing rules encoded properly, PDF quotes and invoices generated on the spot, payment status tracked in one place.
• Admin dashboards & reporting: the numbers your managers currently rebuild by hand every Monday morning, produced automatically.
• Multi-tenant SaaS: a product you sell to other companies, with subscriptions, per-account isolation and self-service onboarding.

What every build includes

• A real data model. Designed and reviewed with you before a line of interface is written, because this is the part that is expensive to change later.
• Accounts, roles and permissions. Who can see what, who can approve what, and an audit trail of who changed it.
• An admin interface your non-technical staff can actually operate. It’s Django’s admin, tailored, not raw.
• Automated tests and CI. Every push runs the suite. You get a green check before anything reaches production.
• A deployment you can reproduce. Docker, environment configuration, database backups and a documented rollback.
• Written documentation and a recorded walkthrough at handover, so the knowledge doesn’t live only in our heads.

The stack, and why

• Django: batteries included, twenty years of security hardening, and a large pool of developers who can maintain it after us.
• PostgreSQL: the boring, correct choice for data you cannot afford to lose.
• HTMX + Tailwind: modern, responsive interfaces without dragging an entire single-page-app framework (and its maintenance burden) into a business tool.
• Celery + Redis: for anything that should not block a user: emails, reports, imports, scheduled jobs.
• Django REST Framework: when your app needs to talk to a mobile client or another system.
• Docker + GitHub Actions: same environment on every machine, automated checks on every change.

A marketing site has one job: convince a stranger you are competent, then get them to contact you. Most fail at the first step by loading in six seconds and looking like nine thousand other sites from the same template pack.

• Designed, not assembled. Layout and typography chosen for your content, not poured into a bought theme.
• Genuinely fast. Real Core Web Vitals targets, images optimised, no third-party script soup.
• Findable. Semantic markup, structured data, sitemaps, meta tags and a sane URL structure from day one, not bolted on later.
• Accessible. Keyboard navigation, contrast that passes WCAG AA, screen-reader-sane structure. This site you are reading is built to the same standard.
• Editable. Delivered as static files or Django templates with a small CMS layer, depending on how often you actually change content.
• Measured. Analytics and conversion tracking configured so you can see whether it works.

The developer left. The framework is four major versions behind. Deployments happen by hand and everyone holds their breath. This is a common situation and it is fixable more often than people assume.

We start with a paid audit

A few days of reading the code, running it, and testing what it actually does. You get a written document covering security exposure, dependency risk, test coverage, deployment fragility and a prioritised list of what to fix first, plus an honest verdict on whether repairing is cheaper than rebuilding. That document is yours whether or not you continue with us.

Then, if it makes sense

• Stabilise. Get it into version control properly, containerise it, make deployment repeatable.
• Secure. Patch known vulnerabilities, rotate exposed credentials, close the obvious doors.
• Cover. Write tests around the critical paths so future changes stop being terrifying.
• Upgrade. Move framework and dependency versions forward incrementally, not in one heroic leap.
• Document. Write down how it works, so the next person is not in your position.

Ongoing care plans

Once it is healthy, a monthly plan keeps it that way: hosting supervision, security updates, verified backups, uptime monitoring and an agreed allowance of change requests. No plan locks you in for more than a month at a time.