UPTIME IS REVENUE · INFRASTRUCTURE THAT EARNS ITS BILL
Most agency DevOps is “we’ll put it on AWS and figure it out.’ Ours isn’t. We run the infrastructure behind DiNePa’s 99.4% uptime SaaS for European enterprise procurement, the isolated intranet deployment of Nepal Rastra Bank’s litigation system in year five of central-bank-grade production, and mobile back-ends serving 500,000+ daily transactions on Upkeep.pro. CI/CD, infrastructure-as-code, observability, SRE practice, and the kind of cost discipline that turns AWS bills into something you can actually defend in a board meeting.
48-hour response · NDA on request · Your first call is with an engineer, not a sales rep
THE PROBLEM
Infrastructure that should accelerate the business ends up doing the opposite. It dies at deployment friction — releases that used to take an hour take three days because the deploy pipeline has accumulated five years of duct tape, and engineers stop wanting to ship. It dies at cost — the AWS bill grows 30% year-over-year with no clear line item for what changed, until the CFO starts asking questions and nobody on the engineering team can answer them.
It dies at observability — the monitoring dashboard lights up red at 3am and nobody knows what to do, because the alerts were configured by someone who left the company two years ago. It dies at on-call — a senior engineer is the de-facto SRE because nobody set up the rotation, the runbooks, the escalation tree.
And it dies at year-three migration — when a critical dependency reaches end-of-life, when the cloud bill forces a re-architecture, when a regulatory change requires moving data residency. We engineer for all of this from day one. DiNePa’s 99.4% uptime over five-plus years isn’t a marketing number — it’s the result of architecture decisions made before the first server was provisioned. NRB’s intranet deployment isn’t still running in year five by accident.
OUR APPROACH
If you already have infrastructure (most engagements do), we start by understanding it. What’s deployed where? What’s the deploy process? Where does the cost actually go? What breaks at 3am? What’s the disaster recovery plan if the primary region fails right now? Deliverable: a written current-state report, prioritised improvement list, and a fixed-price quote for the work.
We design the target state. Cloud provider (or providers) per regulatory environment. Containerisation strategy (do you actually need Kubernetes? often no). CI/CD pipeline. Infrastructure-as-code definitions. Observability stack (logs, metrics, traces, alerts). On-call rotation and runbook structure. Cost model with budgets per service. Disaster recovery RPO/RTO targets. Each decision documented with the trade-off.
Migration to the new infrastructure happens in safe, reversible phases — we don’t do big-bang re-architectures unless they’re explicitly required. CI/CD pipelines first (so every subsequent deploy is faster and safer). IaC second (so the infra is in version control). Observability third (so we can verify the migration is working). Then the actual workload moves, with rollback paths at every step.
Cloud bills creep, dependencies reach EOL, OS images need patching, certs need rotation, alerts need tuning as the system evolves. The retainer covers on-call response (during your business hours or 24×7 as required), monthly cost reviews, quarterly disaster recovery drills, security patch cycles, and the inevitable scaling event when a new client onboards. DiNePa and Upkeep.pro are both on this model.
CAPABILITIES WE SHIP
Not feature lists — the actual infrastructure patterns running our reference deployments today.
What it does: Automated build, test, deploy from git commit to production with rollback paths. Branch protection, automated security scanning, deploy windows, canary releases for high-risk systems.
Stack: GitHub Actions, GitLab CI, or Jenkins picked per client’s git host. Reference: every active client engagement.
What it does: Multi-region, multi-AZ, auto-scaling architecture matched to your regulatory environment and cost profile. AWS for US healthcare (BAA-signed services); EU-region for European clients; isolated intranet for central-bank deployments.
Reference: NRB intranet (Nepal), DiNePa multi-tenant SaaS (EU), Upkeep.pro mobile back-end.
What it does: Docker for app packaging, Docker Compose for simple multi-service deployments, Kubernetes when the scale and operational maturity actually justify it (often it doesn’t). We talk you out of K8s when you don’t need it.
Reference: Container-based deployments across SaaS, marketplace, and healthcare engagements.
What it does: All infrastructure defined in version-controlled code — cloud resources, networking, security groups, IAM roles, secrets. No more “the engineer who set this up left.” Drift detection, peer-reviewed changes, reproducible environments.
Stack: Terraform (most engagements), Pulumi when TypeScript fits the team better.
What it does: Structured logging, metrics with cardinality control, distributed tracing for multi-service requests, alerting that actually correlates to user impact (not just CPU spikes). Runbooks tied to every alert so the on-call engineer knows what to do.
Stack: Prometheus + Grafana, CloudWatch, Datadog, or Sentry depending on client preference and budget.
What it does: Defined SLOs (not just SLAs), error budgets, incident response playbooks, blameless postmortems, on-call rotation with PagerDuty / Opsgenie integration. We can run the rotation for you (during business hours or 24×7) or train your team to run it themselves.
Reference: DiNePa and Upkeep.pro on ongoing SRE retainer.
DEEP DIVE
DiNePa is a multi-tenant real-time digital negotiation SaaS used by European enterprise procurement teams. Their customers run live tenders with up to 80 concurrent suppliers competing across 100+ weighted line items — meaning the system needs to be available exactly when their customers are running revenue-generating events. Downtime during a live tender doesn’t just lose data, it loses negotiating leverage. The uptime target wasn’t a marketing number; it was a contractual requirement.
Multi-region cloud deployment with EU data residency. Active-passive failover for stateful workloads, active-active for stateless. Read replicas for reporting workloads so they never compete with live bidding for database resources. Connection pooling and circuit breakers in front of every downstream service. Health checks at every layer (load balancer, app server, database) with automated rollback if a deploy degrades any of them. Structured logging with correlation IDs across every service so a single failed request can be traced end-to-end. Alerting tied to user-impact metrics (failed bid submissions, recalculation latency above target) rather than infrastructure metrics (CPU, memory). On-call rotation with documented runbooks for every alert.
The result, sustained over 5+ years in production: 99.4% uptime. Real-time bid recalculation latency held under 500ms at 80-supplier concurrency. Multi-stage CSV validation pipeline driving operator error rate under 0.3% on bulk imports. Zero cross-tenant data incidents in five years of EU enterprise operation.
Reliability at this level isn’t accidental. It’s the cumulative result of every architecture decision: schema-per-tenant isolation that survives load tests, observability that catches degradation before users notice, on-call practice that responds in minutes not hours, IaC that lets us reproduce the production environment exactly in staging. That same engineering discipline is what we bring to every DevOps engagement, regardless of vertical.
TECH STACK
HOW WE ENGAGE
1–2 weeks · fixed fee
Best when you have infrastructure that’s become a tax and you need someone to tell you what’s actually wrong. We audit the deploy process, cost model, observability, disaster recovery plan, and on-call practice. Deliverable: written current-state report, prioritised improvement list, fixed-price quote for the work.
2–6 months · fixed price
Best when you have a defined scope: new infrastructure for a launch, migration from one cloud to another, CI/CD overhaul, observability stack build-out. We deliver in safe reversible phases — CI/CD first, IaC second, observability third, then the actual workload moves with rollback paths.
Monthly · time-and-materials
Best post-launch. On-call response (business hours or 24×7), monthly cost reviews, quarterly DR drills, security patch cycles, scaling events. We can run the rotation for you, or train your team to run it themselves — we don’t mind which path you pick.
Standard contracts: MSA + SOW on request. BAA for healthcare engagements where infrastructure touches PHI. We can hold AWS / DigitalOcean accounts during build (transferred to you on launch) or operate inside your existing cloud account.
QUESTIONS
We pick per project. AWS for US healthcare (BAA-signed services), enterprise scale, and existing AWS shops. DigitalOcean for startups and SMB SaaS where cost predictability matters more than feature surface. GCP and Azure when the client already has commit there or when specific services (BigQuery, certain ML offerings) justify it. We never re-platform a client just because we have a favourite cloud.
Probably not. Kubernetes is the right answer for systems with genuine multi-service complexity, traffic that justifies multi-node clusters, and an operational team able to run it. For most SMB SaaS, a few Docker containers on managed compute (ECS, Fargate, App Platform) is simpler, cheaper, and more reliable. We’ll talk you out of K8s if you don’t need it.
Yes — common engagement. We audit the current state (resources, costs, IAM, security posture, deploy process), document everything in Terraform, fix the highest-impact issues first, and migrate to standardised patterns over time. We don’t do big-bang re-architectures unless they’re explicitly required.
Monthly cost reviews are standard. We tag resources by service / team so the bill is attributable, identify over-provisioned compute and storage, recommend reserved instances or savings plans where the workload justifies them, surface unused resources for cleanup. Most engagements see 15–30% cost reduction in the first six months without any service-level changes.
Defined as RPO (recovery point objective) and RTO (recovery time objective) per workload in the architecture phase. Automated backups (with periodic restore testing — backups you haven’t restored aren’t backups), cross-region replication for critical state, documented runbooks for region-failure scenarios. Quarterly DR drills are part of the retainer.
Yes — during business hours, extended hours, or 24×7 depending on what your SLA requires. We can also train your team to run their own rotation if you prefer to keep on-call in-house, including runbook authoring and post-incident review practice.
1–2 weeks current-state audit, then 2–6 months for the migration / build depending on scope. Simple CI/CD overhaul: closer to 2 months. Full cloud migration with IaC, observability, and SRE practice build-out: closer to 6.
We’re listed on Capterra at 4.8★ across 25 verified client reviews — with verified reviewers across real estate, automotive, sports, non-profit, marketing, and auction industries. Read the reviews on Capterra →
Same engineering team. Same SRE discipline. Your infrastructure, with the deploy process, observability stack, and cost model that turn DevOps from a tax into an accelerant.
Cloud bill out of control or infrastructure on fire? +977 9851038796 — Roshan Subedi, Founder & MD · emergency audits reviewed directly