Platform Engineer

At Auto Europe, we're not hiring someone to keep the lights on.

We're hiring someone who builds the platform our engineers ship on, and treats those engineers as their customers.

Someone who automates the thing they had to do twice. Someone who'd rather fix the cause of an incident than get good at firefighting it. Someone with no ego about being wrong, because being wrong fast is how you get right.

If that's you, keep reading.

About the role

You'll join our Technology team in Lisbon to build and run the platform behind our products: AWS, Kubernetes, CI/CD pipelines and infrastructure as code.

You'll work directly with the engineering teams who build on top of it.

The technical bar is high. But the human bar matters just as much.

At Auto Europe, the platform is a product too, and its users are our engineers. You'll understand how they work, where they lose time and what slows them down. You'll push back when a shortcut creates risk. You'll propose trade-offs without drama. You'll own what you build, from the first commit to how it behaves in production.

Here, we are all product.

What you'll actually do

Build the road to production

You'll design, build and maintain our CI/CD pipelines. Builds, tests, deployments. Automated, fast and boring in the best possible way. Deployments go out through GitOps with ArgoCD, so what's in Git is what's running.

Every engineer should be able to ship safely without asking for help. That's the standard you'll set. And you'll know when a clever pipeline is actually a liability.

Infrastructure as code, not tribal knowledge

You'll provision our cloud infrastructure with Terraform and configure it with Ansible. Environments that are consistent, reproducible and easy to reason about.

If it only lives in someone's head or in a console click, it doesn't count.

Run containers in production

You'll run our containerized services on Kubernetes (EKS), packaged with Helm. Deployments, rollbacks, capacity, cost. You'll keep it healthy and keep it simple.

Own reliability, not just uptime

Monitoring. Logging. Alerting. Incident response. These aren't someone else's problems.

You'll build observability with Prometheus, Grafana and our OpenSearch logging stack, so we see problems before our customers do. You'll take part in the on-call rotation, lead the fix when things break, and run the blameless post-incident review so the same thing doesn't break twice.

Build security in, don't bolt it on

You'll bring DevSecOps practices into our pipelines and infrastructure. Vulnerability scanning. Access control. Policy as code. Secrets handled properly in Vault. Security that doesn't slow teams down, because it's already part of how they ship.

Automate the boring work

If you've done it twice by hand, you'll script it the third time. Less manual work, fewer mistakes, more time for the problems that actually need a human.

Keep the customer in the room

Every minute of downtime affects someone, somewhere in the world, trying to rent a car. That matters.

You'll understand how platform decisions show up for our customers: slow pages, failed bookings, outages at the worst possible moment. And you'll use that to decide what to fix first.

Cross-functional by default

You'll work side by side with developers to improve application performance, troubleshoot issues and smooth out the way we build and release software. You'll explain trade-offs in plain language, write the runbook, share what you know, and make sure everyone understands what's happening and why.

No silos. No throwing things over the wall. In either direction.

AI-first mindset

You actively use AI tools to move faster and think better. You know when to trust them and when to challenge them, and you bring that thinking into how the team works, from drafting Terraform modules to making sense of an incident timeline.

The stack

Must have

• Cloud: AWS, where our platform runs

• Infrastructure as code: Terraform, Ansible, CloudFormation

• CI/CD and GitOps: Jenkins, GitLab CI, ArgoCD

• Containers: Docker, Kubernetes (EKS), Helm

• Observability: Prometheus, Grafana, Alertmanager, log pipelines (OpenSearch/ELK, Fluent Bit)

• Scripting: Bash and Python

• Foundations: Linux, networking (DNS, load balancing, TLS), Git

Nice to have (real advantage)

• Azure: multi-cloud experience

• DevSecOps tooling: vulnerability scanning, policy as code (OPA, Checkov), access management

• Kubernetes ecosystem: Karpenter, cert-manager, External Secrets

• Other AWS compute: ECS/Fargate, Lambda

• Data and messaging: MySQL, Redis, RabbitMQ, SQS, Kafka

• Our application stack: PHP, Laravel, React, microservices

• GitHub Actions

• Secrets management: HashiCorp Vault

What you bring

• 5+ years in a DevOps or Platform Engineering role

• Strong AWS experience, production-grade. This is the core.

• Infrastructure as code: hands-on with Terraform, Ansible or CloudFormation

• CI/CD: you have built and maintained real pipelines, not just used them

• Docker and Kubernetes: solid experience running containers in production

• At least one scripting language (Bash, Python or similar) that you use every day

• Git: confident, daily use

• Monitoring and logging: familiarity with Prometheus, Grafana, ELK or similar

• A troubleshooter’s mindset: you stay calm, dig for the root cause and fix it for good

• A degree in Computer Science or a related field, or equivalent hands-on experience

• Strong English, written and spoken