Custom Software
Applications built from the domain up, in languages and frameworks chosen for the next decade — not the last one.
LIT DEALS LTD is an independent studio for custom software, cloud platforms and integrations. We take a small number of projects, write the code ourselves, and stay long enough to keep them healthy in production.

We build software the way a good workshop builds anything worth keeping — slowly, deliberately, and with the people who will use it. Most of what we ship is invisible: internal tools, back-office systems, integrations that let other software finally speak to each other. It is the plumbing of a business, and we take it seriously.
LIT DEALS LTD works with founders, operators and engineering leaders who want a technical partner rather than a vendor. We are deliberately small. A project has a lead engineer who owns it end to end, from the first workshop to the fifth quiet quarter after launch when nothing breaks and everything simply works.
A concentrated set of services chosen because they compound. We do not chase trends; we deepen what already works.
Applications built from the domain up, in languages and frameworks chosen for the next decade — not the last one.
Infrastructure as code, container orchestration and pipelines that make deployment routine instead of eventful.
Bringing ERPs, CRMs, payment gateways and internal services into a single, observable narrative.
Customer-facing surfaces designed for performance, accessibility and search — the way the modern web expects.
Careful refactors, incremental rewrites and language migrations that keep the business running throughout.
Automated testing, staged environments and long-term maintenance contracts that make software a living thing.

A short, intense phase of interviews, architecture sketches and constraints. The output is a written brief we both sign.
The riskiest slice built first, in production-grade code, so decisions are made against something real rather than a slide.
Weekly demos, small pull requests, continuous deployment. Nothing accumulates unseen for a month.
We stay: monitoring, incident response, quarterly reviews and roadmap conversations for as long as it makes sense.
"Good software is a quiet inheritance. It arrives without ceremony, saves someone hours every day, and is still there, still working, when the team that built it has long since moved on."
We tend to be called when the spreadsheet has become load-bearing, or the platform that carried the company through year three is starting to strain in year five.
We treat infrastructure as a first-class part of the product. Environments are reproducible, deployments are observable, and the path from a developer's laptop to production is a single, boring pipeline that behaves the same at 03:00 as it does at 15:00.
AWS, GCP, Azure and self-hosted stacks. Kubernetes when it earns its place.
Relational and document stores, message queues, warehouses, caches — chosen per workload.
Structured logging, metrics and traces wired in from day one, not bolted on after an incident.
Least-privilege access, secret management, dependency scanning and sensible default hardening.

We are generalists by training and specialists by engagement. These are the environments we tend to feel at home in.
Choices are made per project, but these are the technologies our engineers know deeply and default to when there is no reason to do otherwise.

Every meaningful decision lives in a document a new engineer can read a year from now.
Automated tests exist to prove behavior, not to hit a coverage number. We write the ones that pay their rent.
Feature flags, staged rollouts and clear rollback plans. A deploy that cannot be undone is a deploy we don't do.
The engineer who built it is the engineer who is paged when it misbehaves. That focuses the mind wonderfully.
Security is treated as a design constraint, not a review at the end. Access is scoped, secrets are managed centrally, dependencies are watched, and sensitive paths are audited. We assume that anything worth building is also worth attacking, and we design accordingly.
Scale is handled the same way. We prefer boring, well-understood patterns — clear service boundaries, idempotent operations, queue-first workflows, cache invalidation you can actually reason about. When something must be exotic, we document precisely why, so the next engineer inherits a decision rather than a mystery.

With a short discovery conversation over email, followed by a paid discovery week if the fit looks right. The output is a written brief and a fixed proposal for the first phase.
Both. Discovery is fixed; delivery is scoped in short milestones. Long-term maintenance is a monthly retainer. We choose whichever removes the most ambiguity for the client.
Yes. Many engagements are embedded, with our engineers pairing with in-house developers, sharing patterns and gradually handing over ownership.
Yes, as a matter of course. Everything discussed with a prospective client is treated as confidential from the first message.
We operate remotely by default and travel for kick-offs, key workshops and critical launches when it clearly helps the work.
We stay. Every project we ship has a monitoring plan, an on-call arrangement and a quarterly review. Software is an ongoing relationship, not a delivery.
Whether you have a brief in mind or a problem you can't quite describe yet, a short email is the best place to start. We reply to every serious enquiry.
