Web Development
Production web applications and platforms — typed end to end, accessible by default, and fast on the devices your users actually have.
Software Engineering Studio
APERTRIZE
We design and build enterprise-grade web, mobile and AI systems — architected for security, built to scale, and supported long after launch.
We build the software companies actually run on.
Trusted to run production systems for
-
Ozone Greens
Services
Everything required to take a system from idea to production — and keep it there.
One team across the whole stack, so nothing falls between disciplines.
Mobile App Development
Cross-platform apps that feel native on both stores — offline- capable, release-managed, and sharing one codebase with your web platform where it makes sense.
AI Solutions
Forecasting, classification and language features built into your product — evaluated against real data, with the accuracy and failure modes stated up front.
Cloud & DevOps
Containerised deployments, health-checked services and CI that runs the full test suite on every push — so shipping is routine rather than an event.
Security & Maintenance
Threat modelling, tenant isolation, audit trails and dependency scanning — plus the ongoing support agreement that keeps all of it true a year from now.
Featured work
Systems in production, not concepts in a deck.
Two engagements, described the way an engineering team would describe them: the constraint, the decision, and what shipped.
Diesel Management System
Ozone Greens · Multi-tenant operations platform · Live in production
Live
Multi-tenant SaaS
The problem
Daily generator operations — diesel filling, closing stock, KWH and house counts across a roster of generators — lived in a hand-maintained spreadsheet. Formulas drifted between months, history was hard to query, and nothing could be audited or safely shared beyond one machine.
What we built
A company-aware platform that replaced the spreadsheet and then outgrew it: governed sites and generators, atomic change sets for equipment lifecycle, adaptive demand forecasting backtested against real history, and a platform console that provisions further customer companies in full isolation.
How it holds up
Tenant scoping is re-derived from the database on every single request, never trusted from a token — and that claim is proven by an adversarial test suite that actively attempts cross-tenant access across every feature area.
Selected capabilities
- Change sets that preview projected impact and conflicts, then publish atomically or on a future effective date
- Adaptive diesel-demand forecasting with confidence ranges, backtested against historical consumption
- Historical Excel import with server-side validation and a zero-mutation preview step before anything is written
- Optional TOTP multi-factor auth, progressive account lockout and IP-keyed rate limiting on every sensitive endpoint
- Separate role-scoped experiences for employees, company admins and the platform owner
- Full audit trail — every administrative action and login outcome recorded and browsable
Company admin dashboard — consumption trends, stock levels and alerts at a glance.
Adaptive forecasting — next day, week and month with confidence ranges.
Interactive analysis — selectable metrics across week, month, year or custom ranges.
Change sets — plan generator lifecycle actions, preview conflicts, publish atomically.
850+
Automated tests running in CI on every push
3
Isolated roles, each re-verified from the database per request
Zero
Raw SQL statements — every query goes through the ORM layer
15 min
Access-token lifetime, with instant server-side revocation
AI Chess Analysis Platform
Internal R&D · Engine-backed game analysis · Technical showcase
AI & Full-stack
Engine integration
The premise
Chess platforms will tell a player they lost. They rarely tell them where, or why. We wanted a system that ingests a real player's history from the public platforms and returns move-level explanation rather than a single score.
The engineering
A FastAPI service fetches and normalises games from the Lichess and Chess.com APIs, parses PGN into positions, and drives a Stockfish evaluation pass over each one. A classification layer turns raw centipawn deltas into human-readable move quality and per-game accuracy.
Why it matters here
It is the same shape as most applied-AI work we take on: an external data source, a compute-heavy analysis step that cannot block a request, and a domain model that has to turn model output into something a non-expert can act on.
Technical highlights
- Unified ingestion across two third-party APIs with differing schemas, rate limits and PGN conventions
- Stockfish evaluation pipeline with a move classifier that converts centipawn loss into labelled move quality
- Per-game accuracy scoring and rating-trend analysis over a player's full history
- Interactive React board with move-by-move replay and inline engine commentary
- Service-per-concern backend — fetching, parsing, evaluation and classification are independently testable
- Activity heat-mapping and per-format statistics for bullet, blitz and rapid
How we work
A process designed to remove surprises.
Seven stages, each with a defined output. You always know what is being worked on, what comes next, and what you are signing off.
Discovery
We start with how the work is actually done today — the spreadsheet, the workaround, the thing everyone knows is broken. Understanding the existing process is what stops us building a faster version of the wrong system.
Planning
Scope is broken into phases that each end in something usable. You get the architecture, the data model, the sequence and the trade-offs in writing before a line of code is committed.
Design
Interface design happens against real data and real roles, not placeholder text. Every screen is checked for contrast, keyboard operation and behaviour at mobile widths before it is approved.
Development
Built in reviewable increments against a linear migration history, with business logic isolated from transport so it stays testable. You see working software throughout, not at the end.
Testing
Automated coverage across the backend and frontend, plus adversarial suites for the things that must never fail — access control, tenant isolation, and any calculation the business depends on.
Deployment
Containerised, health-checked services with a documented rollback path. Environments are reproducible, secrets are guarded at boot, and the deploy is a routine command rather than an event.
Support
Dependency scanning, security patching and a named point of contact. Systems drift when nobody owns them — the support agreement is what keeps everything above still true in a year.
Technology
Chosen for what they will cost you in three years.
We work in mature, well-supported technology with real hiring pools — so your system stays maintainable by someone other than us.
React
TypeScript
Vite
TanStack Query
React Hook Form
Zod
Radix UI
React Native
GSAP
WebGL / GLSL
Python 3.12
FastAPI
SQLAlchemy 2
Alembic
Pydantic v2
Node.js
REST / OpenAPI
Argon2id
JWT / TOTP
pytest
PostgreSQL 16
SQLite
Redis
Row-level tenancy
Linear migrations
Optimistic concurrency
Docker
Docker Compose
nginx
Caddy
Railway
GitHub Actions
Dependabot
CodeQL
LLM integration
RAG pipelines
NumPy
Matplotlib
Time-series forecasting
Stockfish
python-chess
Model evaluation
Why Apertrize
The difference shows up after launch.
Modern Technology
Current, actively maintained stacks — never a framework you will struggle to hire for or a version that lost support two years ago.
Fast Delivery
Phased scope where every phase ends in something you can actually use, so value arrives early instead of all at once at the end.
Scalable Architecture
Multi-tenancy, role separation and clean service boundaries designed in from the first migration — not retrofitted once they hurt.
Secure Development
Threat modelling, least privilege and audit trails as defaults. Security claims are backed by tests that try to break them.
Performance Optimized
Measured, not assumed. Payloads, queries and render paths are profiled against real data and real devices before sign-off.
Long-Term Support
Documentation, runbooks and a decisions log handed over with the code — so the system outlives whoever happens to be on the team.
About
A studio built around one belief: software should be dependable before it is impressive.
Apertrize is a software engineering studio. We build the operational systems businesses depend on daily — the platform that replaces the spreadsheet, the tool the whole team logs into every morning, the service that cannot be down.
What we build
Multi-tenant platforms, internal operations tools, customer- facing web and mobile products, and applied-AI features that sit inside them. Work that has real users, real data and real consequences when it breaks — which is precisely why we hold it to an engineering standard rather than a demo standard.
Why we exist
Serious businesses are routinely handed software built to look finished rather than to last: no tests, no audit trail, no migration path, and nobody to call a year later. Apertrize exists to close that gap — to give small and mid-sized organisations the engineering discipline usually reserved for large in-house teams.
Mission
To build software our clients can trust without having to understand it — secure by construction, documented on handover, and supported for as long as they run it.
Vision
To become the engineering partner that growing organisations keep, not the vendor they replace — measured by how many of our systems are still running, and still being extended, years after launch.
Sai Saran
Founder & Software Engineer
Sai Saran founded Apertrize to build production software to a standard he found missing in the tools small organisations were being sold. He leads the studio's engineering — architecture, security model and delivery — and remains hands-on across every engagement.
He is the architect and principal engineer of the Apertrize Diesel Management platform, taking it from a single customer's spreadsheet replacement to a governed multi-tenant system with role-separated access, an adversarial tenant-isolation test suite and adaptive demand forecasting. His work on engine-backed chess analysis covers the other half of the studio's practice: third-party data ingestion, compute-heavy evaluation pipelines, and turning model output into something a non-expert can act on.
He is completing a B.Tech in Computer Science with a specialisation in Artificial Intelligence at Bharath Institute of Higher Education and Research, and holds certifications in AI/ML through the Google–EduSkills virtual internship programme and in next-generation cyber defence covering threat analytics and digital forensics.
Client feedback
What our clients say.
Feedback is published, not written
Our first engagements are in production and ongoing. We publish client feedback only once a project has run long enough for the client to judge it honestly — attributed, with a name and a role attached. This space is reserved for exactly that.
Talk to a reference client
If you would rather hear it directly, we can arrange a conversation with a client currently running one of our systems in production. Ask us during the first call.
FAQ
Questions worth asking before you hire anyone.
What does a project typically cost?
Cost follows scope, and scope is fixed per phase rather than for an entire project up front. After discovery you receive a written plan broken into phases, each with its own price and deliverable — so you can commit incrementally and stop at any phase boundary without being left with something unusable.
How long does a build take?
A focused internal tool typically reaches production in three to eight weeks. A multi-tenant platform with role separation, reporting and an audit trail is a phased engagement measured in months. We give you a phase-by-phase schedule after discovery, and every phase ends in software you can use.
Who owns the code and the data?
You do — in full. On completion of the project and final payment, ownership of the source code transfers to you, together with the repository and its complete commit history, the infrastructure configuration, the migration history and the documentation. There is no proprietary runtime you have to keep licensing from us in order to run your own system.
Owning it does not oblige you to operate it. If you would rather not run the infrastructure yourself, we offer a managed service covering hosting, monitoring, maintenance and ongoing support — the same system, run by the team that built it. That is always your choice, never a condition: the handover is complete either way.
Can you take over an existing codebase?
Yes, and it is common. We begin with a paid audit covering architecture, security posture, test coverage and dependency health, and report back on what is worth keeping, what needs replacing, and what it will cost. You are free to act on that report with us or with anyone else.
What happens after launch?
Every build ends with handover documentation, runbooks and a decisions log explaining why the system is shaped the way it is. From there, a support agreement covers security patching, dependency updates, monitoring and a defined response time, with a named point of contact rather than a ticket queue.
How do you handle security and compliance?
Security is designed in, then tested adversarially. That means modern password hashing, optional multi-factor auth, short-lived sessions with server-side revocation, role checks re-verified from the database on every request, and — where multiple customers share a deployment — a dedicated test suite that actively attempts cross-tenant access and must fail to achieve it.
Do you work with clients outside India?
Yes. We work remotely with clients in any time zone and keep a guaranteed overlap window with your working hours for calls and reviews. Written updates, plans and decisions are the default, so progress never depends on catching us live.
What do you need from us to start?
Access to whoever actually does the work today, and to whatever they currently use — the spreadsheet, the legacy tool, the manual process. One decision-maker who can approve scope is enough on your side. We handle the rest, including the parts nobody has written down yet.
Contact
Tell us what needs building.
Send us the problem — not a specification. The first call is a conversation about what is actually going wrong, and you leave it with an honest view of scope, cost and whether we are the right team for it.