Product & platform
Cloud, DevOps & platform
Infrastructure as code in your accounts, pipelines that deploy safely, and the observability to know what is happening. Plus the part most teams skip until the invoice arrives: knowing what each feature costs to run.
- AWS
- GCP
- Azure
- Kubernetes
- Serverless
- IaC
- CI/CD
- Observability
- FinOps
What we build
- Infrastructure as code
- Terraform or Pulumi in your repository, reviewable in a pull request.
- Deployment pipelines
- Build, test, staged rollout and a rollback that has actually been rehearsed.
- Container and serverless platforms
- Kubernetes where it earns its complexity, managed runtimes where it does not.
- Observability stack
- Traces, metrics, logs and dashboards, with alerts that mean something at 3am.
- Cost visibility
- Per-feature and per-run cost attribution, including model inference spend.
- Runbooks and on-call
- Written procedures for the failures you can predict, and an escalation path.
Problems this solves
- Problem
- Nobody is certain how production got into its current state.
- Approach
- Bring everything under infrastructure as code, then make manual changes fail rather than drift.
- Outcome
- The repository is the truth, and rebuilding an environment is a command.
- Problem
- The cloud bill grows and no one can attribute it.
- Approach
- Tag and attribute spend per service and per feature, including model inference, and set budget alerts.
- Outcome
- Cost becomes a number in the sprint review instead of a quarterly surprise.
- Problem
- Deploys are rare and frightening, so changes pile up.
- Approach
- Automated pipelines with staged rollout, health gates and a rehearsed rollback path.
- Outcome
- Small, frequent, boring deploys — which is what makes them safe.
How we approach it
Discover
We audit what is running and what it costs, inside your accounts. The first week usually finds something that has been billing for a year and serving nobody.
Design
Environments are designed as one definition with different variables, so staging genuinely resembles production. Access, secrets and network boundaries are decided before anything is created.
Engineer
Infrastructure as code from the first resource — no console clicks only one person remembers. The same pipeline deploys to every environment, which is what makes staging mean something.
Evaluate & harden
Failure is rehearsed: rollbacks, restores from backup, and what happens when a dependency is down. Alerts are tuned to the point where somebody would actually act on one.
Launch & operate
Cost is tagged per service and on a dashboard rather than discovered monthly. On-call runs against runbooks your team wrote with us, and the credentials are yours from the first day.
What we build it with
One service definition, one autoscaling policy, and cost attribution as a tag — so the question of what a feature costs to run has an answer.
# Every environment is this file with a different tfvars.
module "service" {
source = "../modules/ecs-service"
name = var.service_name
image = "${aws_ecr_repository.app.repository_url}:${var.sha}"
cpu = 512
memory = 1024
desired_count = var.environment == "prod" ? 3 : 1
# Cost visibility is a tag, not a spreadsheet someone maintains.
tags = {
Environment = var.environment
CostCentre = var.cost_centre
ManagedBy = "terraform"
}
}
resource "aws_appautoscaling_policy" "cpu" {
name = "${var.service_name}-cpu"
service_namespace = "ecs"
scalable_dimension = "ecs:service:DesiredCount"
resource_id = module.service.autoscaling_target
target_tracking_scaling_policy_configuration {
target_value = 60
predefined_metric_specification {
predefined_metric_type = "ECSServiceAverageCPUUtilization"
}
}
}Cloud, DevOps & platform
- AWS
- Google Cloud
- Azure
- Docker
- Kubernetes
- Terraform
- GitHub Actions
Observability & evaluation
- Grafana
- Prometheus
Questions we get asked
Do we need Kubernetes?
Probably not. Most products run better and cheaper on managed containers or serverless until the team is large enough that the platform's uniformity earns back its operational cost. We will tell you when you have crossed that line, and not before.
Will this run in our own cloud accounts?
Yes, always. Your accounts, your Terraform state, your billing. We work inside your organisation's guardrails rather than standing up a parallel environment you would later have to migrate out of.
Can you help reduce what we already spend?
Usually. The pattern is nearly always the same: untagged resources, oversized instances, idle non-production environments and unbatched model calls. We attribute the spend first, then fix the three things that account for most of it.
Do you provide ongoing operations?
Under a Managed & Support retainer — monitoring, on-call cover, upgrades and iteration with an agreed response window. Or we hand over runbooks and a walkthrough so your team runs it. Both are real options; we do not make the handover deliberately hard.
Tell us what you are trying to ship.
A first call is 30 minutes and costs nothing. Bring the problem rather than a spec — the useful part is usually working out whether this is the right shape of solution at all.
contact@algologix.coWe reply within 24 hours.