A small studio, working carefully, on systems that will outlive the brief.
Discipline
Software engineering, IT infrastructure and operational technology — practised as one discipline.
SERT PROPERTY VENTURES LTD is an independent technology company. We design, build and support the software and infrastructure that businesses rely on to operate — from internal tools and integrations to production platforms and cloud environments.
We work as a single accountable team. Engagements are structured around specific outcomes, agreed in writing, and revisited on a regular cadence. Nothing about our work depends on scale that we do not have.
To make software behave the way businesses actually work.
Most operational friction is not caused by technology being absent; it is caused by technology that does not match the way work is done. Our mission is to close that gap — by understanding the workflow first and only then choosing what to build.
Fewer, better systems — that businesses can hand down.
We want the systems we build to still be understood a decade from now: legible in the code, sensible in the infrastructure, and documented in a way that respects the people who will eventually inherit them.
Six commitments we hold across every engagement.
- 01
Clarity before code
Every project starts with plain language: what is being built, for whom, and against which measurable outcome.
- 02
Small teams, direct lines
The people writing the code are the same people you speak to. No layers, no relayed messages.
- 03
Legible systems
We treat readability of code, infrastructure and documentation as a first-order requirement, not a courtesy.
- 04
Boring where it counts
Load-bearing components use proven technologies. Novelty is reserved for the places it genuinely helps.
- 05
Written decisions
Choices, trade-offs and constraints are recorded so future teams can understand — and revisit — them.
- 06
Long horizons
We build with the assumption that the software will be alive years from now, and someone else will maintain it.
§ 05 — Technology philosophy
Choose tools you can explain, use tools you can operate.
Every technology choice is a commitment: to keep it running, to hire for it, to explain it to a future maintainer. We take that commitment seriously.
We prefer languages and platforms with long track records, stable communities, and clear operational stories. When a newer tool offers a real advantage, we adopt it deliberately and document why.
We avoid architectural fashions that would demand more moving parts than the problem justifies.
Fewer meetings, more written work.
We collaborate through short, purposeful conversations and clear written artefacts: proposals, decision records, change notes, runbooks. This keeps context durable and reduces the tax of hand-offs.
Clients get a single point of contact who is also involved in the technical work — not a proxy between them and the engineers.
What "done" means, in practice.
- ReviewedAll production code passes peer review before release.
- TestedAutomated tests cover the paths that matter — enough to catch regressions early.
- ObservableSystems emit structured logs, metrics and traces from day one.
- RecoverableBackups, restores and rollback procedures are exercised, not assumed.
- DocumentedThe system can be understood by someone who was not in the room when it was built.
Handle carefully what does not belong to us.
Client data is treated as borrowed, not owned. Access is scoped to the people and processes that need it, encrypted in transit and at rest, and retained no longer than necessary for the work.
Security decisions — from key management to dependency updates — are written down and reviewed periodically, not left to memory.
We plan for year three, not launch day.
Software gets harder to change as it ages, unless deliberate care is taken. We invest in the small habits — clear naming, small modules, honest documentation, disciplined dependencies — that keep systems open to change for years, not months.