Software that ships often
and stays up.

We build, ship and run production systems for teams that cannot afford downtime. One senior team, from the first commit to the 3 a.m. pager.

Book a 30-minute call See the five services
What we ship, not slides. 
# Argo Rollouts. 5% of traffic, measured, then 50%, then everyone.
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: api-gateway
spec:
  replicas: 6
  strategy:
    canary:
      steps:
        - setWeight: 5
        - pause: { duration: 10m }
        - analysis:
            templates: [{ templateName: p99-and-error-rate }]
        - setWeight: 50
        - pause: { duration: 10m }
      abortScaleDownDelaySeconds: 600  # a rollback keeps the old pods warm
# Sloth. The objective is written down, and the pager follows it.
version: prometheus/v1
service: checkout
slos:
  - name: availability
    objective: 99.9
    sli:
      events:
        error_query: sum(rate(http_requests_total{job="checkout",code=~"5.."}[{{.window}}]))
        total_query: sum(rate(http_requests_total{job="checkout"}[{{.window}}]))
    alerting:
      page_alert:   { labels: { severity: page } }
      ticket_alert: { labels: { severity: ticket } }
# k10s: our open-source cluster tool. One static binary, checksum-verified.
$ curl -fsSL https://p10node.com/k10s/install.sh | sh

# Pin a release, or keep it out of /usr/local.
$ K10S_VERSION=v0.1.0 K10S_NO_SUDO=1 sh install.sh

# Source and releases: github.com/p10node/k10s

Across the platforms we manage.

99.98%Average uptime, managed platforms
−46%Median cloud spend cut, year one
12 minMedian time to restore service
140+Environments built and operated

The stack we run in production.

Kubernetes Argo CD Terraform Helm Docker GitHub Actions Prometheus Grafana OpenTelemetry PagerDuty PostgreSQL Apache Kafka HashiCorp Vault Google Cloud Cloudflare NVIDIA

Everything between commit and customer

Take one practice, or the whole delivery path. Reliability and cloud cost are where most teams start.

All five services

SRE, on-call, IaC

Infrastructure & monitoring

Reliability assessment, infrastructure as code, SLOs and tracing, 24/7 on-call and incident command. An honest read on what you run, and eyes on it around the clock.

SLOs, checkout, 30 dayswithin budget
availability99.98%
p99 latency184 ms
error rate0.01%
budget burn39%
Assessment, SLOs, 24/7 on-call

FinOps, migration, compliance

Cloud, cost & compliance

Migration and data centre exit, FinOps, disaster recovery, ISO 27001 and SOC 2 readiness, secrets management.

monthly spend−46% in year one
FinOps, DR, ISO 27001

CI/CD, GitOps

Deployment & delivery

GitOps, preview environments, canary and blue/green rollouts. Every commit gets a safe, reversible path to production.

  • commit, build, sign2m04s
  • preview environmentpr-4821
  • canary 5% → 50%watching
  • prod, rollback armed11m
Pipelines, GitOps, rollouts

GPU, inference

AI infrastructure

GPU capacity and build-vs-rent strategy, inference clusters and autoscaling, cost per thousand requests tracked like any other SLI.

$0.31$1.04per 1k requests, same GPU budget
Capacity, serving, unit cost

Build

Software engineering

Greenfield web, API and data platforms, legacy modernisation and architecture review, built by the engineers who will also run it.

- replicas: 12 # set by hand+ minReplicas: 3+ targetCPU: 65% # measured
Platforms, modernisation, review

It starts with two weeks inside your systems.

The reliability assessment scores architecture, delivery flow, cost and risk. You get a written report and a prioritised roadmap your own team could run without us.

  • Fixed fee, agreed up front. Small enough to buy without a procurement cycle.
  • Your repositories, your cloud accounts. Nothing to hand back at the end.
  • Either side can stop. Retainers run monthly, with 30 days' written notice.

  1. Assess Start here

    Two weeks inside your systems. Architecture, delivery flow, cost and risk, scored.

    Reliability report, prioritised roadmap

  2. Architect

    Target state designed with your team and written down. Nothing lives in someone's head.

    Decision records, migration plan

  3. Automate

    Code, pipelines, policies and dashboards, shipped incrementally. Nothing hand-clicked.

    IaC, CI/CD, SLOs, runbooks

  4. Operate

    We run it with you, or hand it over completely. Documented exit path from day one.

    24/7 cover, monthly reporting

What the last engagements moved

Fintech, commerce and applied AI. Names withheld on request.

−62%Cloud spend

Cloud spend, while traffic tripled

Cost was scaling faster than revenue. Right-sized compute, batch work to spot, budget alerts in front of every team. $1.9M annual saving in 14 weeks.

Traffic
Tripled
Annual saving
$1.9M
Time to result
14 weeks
11 minLead time

Lead time, down from nine days

Deployments took four hours and a war room. GitOps, canary rollouts and preview environments took the retailer from fortnightly releases to 300 a week.

Before
9 days, fortnightly
After
11 min, 300 a week
Rollback
Automatic
3.1×Throughput

Inference throughput, same budget

The team was renting far more GPU than it used. Batching, caching and scale-to-zero cut cost per thousand requests from $1.04 to $0.31.

Cost per 1k requests
$1.04 → $0.31
GPU budget
Unchanged
Idle capacity
Scale-to-zero

Notes from production

What we learned running other people's systems.

Read all insights

  1. The three numbers that decide what your inference costs

    Cost per thousand requests is an SLI. Batching, utilisation and the tail of your latency distribution set it, and most teams are only watching one of them.

  2. Cutting cloud spend, in the order that actually works

    Most cost programmes start with reserved instances and stall. The savings are real but they are last, not first. Here is the sequence we use and why.

  3. What a reliability assessment actually looks at

    Two weeks inside a production system, and the eight questions that decide the score. Most of them are not about the infrastructure.

What teams ask before the first call

The short answers. The long ones are on services.

01 What does p10node do?

p10node builds software, ships it and runs it. One senior team covers software engineering, CI/CD and delivery, infrastructure and monitoring, AI infrastructure, and cloud cost and compliance work - from the first commit to the 3 a.m. pager.

02 Who is p10node for?

Teams that cannot afford downtime: fintech, commerce and applied AI companies across South-East Asia, Europe and Australia. You can take a single practice or the whole delivery path.

03 Where is p10node based, and when are you available?

Ho Chi Minh City, Vietnam, working follow-the-sun. Incidents are answered around the clock with a 15-minute response SLA; ordinary enquiries get a reply within one business day. We work in English and Vietnamese.

04 How are engagements priced?

A fixed monthly figure agreed up front, with no hourly surprises. Retainers run monthly and either side can end one with 30 days' written notice.

05 Who owns the code and infrastructure you build?

You do, from the first commit. The work happens in your repositories and your cloud accounts, and every engagement has a written exit plan from day one.

06 How does an engagement start?

With a two-week reliability assessment: two weeks inside your systems scoring architecture, delivery flow, cost and risk, ending in a written report and a prioritised roadmap your own team could run without us.

07 Do you work on AI and GPU infrastructure?

Yes. GPU capacity planning and build-versus-rent strategy, inference clusters and autoscaling, RAG and vector store architecture, and cost per thousand requests tracked as an SLI like any other.

08 What results have you delivered?

Across the platforms we manage: 99.98% average uptime, a median 12 minutes to restore service, and a median 46% cut in cloud spend in the first year, over 140+ environments built and operated.

Tell us what is breaking, or what you want to build.

A short note reaches an engineer, not a sales sequence. Reply within one business day.

Start a conversation [email protected]