Jaime Martinez | Engineering Manager, Platform & Artifact Infrastructure

About

I lead engineering for GitLab's Package stage. That covers the container registry, the package registry, and artifact registry, GitLab's published direction for centralised artifact management.

My background is backend and infrastructure: Go, PostgreSQL, Redis, object storage, Kubernetes, and cloud platforms across AWS, GCP and Azure. I spent six years at GitLab as a backend engineer and open source maintainer before moving into management, which is the reason I can still hold technical context in the room when we make product and delivery calls.

What I do now

Set direction for secure, scalable artifact storage and distribution across GitLab.com, Self-Managed and Dedicated deployments.
Coordinate execution across storage, databases, authentication and authorisation, infrastructure, frontend and reliability.
Hire, grow and retain engineers, including career development and technical leadership pathways.
Improve delivery systems: milestone planning, clear ownership, asynchronous visibility, and AI-assisted workflows that cut coordination overhead.

Selected outcomes

Led a Core DevOps quality initiative across 13 or more engineering groups: severity 1 and 2 bugs down 65%, total product bugs down 42%, SLO attainment up from 10% to 63%.
Drove the container registry metadata database rollout, unblocking backup and restore capability required for Self-Managed and Dedicated general availability.
Migrated petabytes of metadata from object storage to PostgreSQL, cutting cloud storage cost by around 40%.
Cut self-managed migration time by roughly half with automation for Linux package and Kubernetes Helm environments.
Built a Redis caching layer: 60% less database query load, content serving from about 200ms to about 80ms.

How I think about the work

The hard part of platform engineering is rarely the code. It is getting five teams to agree on the same sequence, then holding that sequence when priorities move. Making the path obvious is most of the job.

I also treat AI as a practical engineering management tool rather than a novelty: reducing repetitive planning and reporting work, surfacing patterns in operational data, and giving the team more room for judgement and design.

Areas I write and speak about

Registry and artifact storage architecture, large-scale and zero-downtime data migration, and cross-team delivery in distributed engineering organisations.

Beyond the work

I train Hyrox and I am working toward my first half marathon. I race Men Open, play volleyball, run, and train in the gym regularly. I do it because I like being strong, and because a training block with a fixed end date is a useful counterweight to work that is never finished.

I grew up in Guadalajara, Mexico, studied in Melbourne, and have worked in Australia since 2015. I work in English and Spanish, and I have spent most of my career as the person in the room from somewhere else. That shapes how I run a team. I pay attention to who is not talking, and I assume the process is the problem before I assume the person is.

I am gay, and open about it at work. Visibility mattered to me earlier in my career when other people were doing it, so I do the same now. At GitLab I am part of the Pride and Gente team member resource groups. Gente is the group for Latinx team members.

Some of the work I am most glad about is not on a roadmap. I built a Go mentoring programme for juniors and newcomers across offices at Assembly Payments. I spent three years volunteering with Intel in Guadalajara, mostly reforestation, sea turtle conservation, and computer lab support at local schools including a school for blind girls. I volunteered with Engineers Without Borders Australia on high school outreach, and spent a few months packing food orders at Foodbank Victoria. I like staying involved in the community and giving back where I can.

Experience

Seven years at GitLab across three roles, preceded by backend and platform work in payments, fintech, health technology and semiconductors.

Engineering Manager, Package stage

GitLab · Nov 2025 to present · Melbourne, remote

Lead engineering for the Package stage: container registry, package registry, and artifact registry, GitLab's published direction for centralised artifact management.
Own product and engineering strategy for artifact storage and distribution across GitLab.com, Self-Managed and Dedicated deployments.
Led GitLab Core DevOps' bug burndown initiative across 13 or more engineering groups: 65% reduction in severity 1 and 2 bugs, 42% reduction in total product bugs, SLO attainment from 10% to 63%.
Led cross-team coordination for the container registry metadata database rollout, unblocking backup and restore capability required for Self-Managed and Dedicated general availability and reducing delivery risk for dependent teams.
Delivered on-time milestones across container registry and package registry by aligning teams on scope, resequencing as priorities shifted, and keeping decisions visible asynchronously.
Built AI-assisted planning, reporting and automation workflows that reduced manual coordination work and improved delivery visibility across the stage.
Manage hiring, performance, career development and technical leadership growth.

Works with engineering management, platform strategy, distributed systems, Go, PostgreSQL, Kubernetes

Senior Backend Engineer, Go

GitLab · May 2022 to Nov 2025 · Melbourne, remote

Orchestrated a petabyte-scale migration of registry metadata from object storage to PostgreSQL, reducing cloud storage cost by around 40% and improving system performance.
Built migration automation for self-managed customers moving to the metadata database, supporting Linux package and Kubernetes Helm chart deployments, cutting migration time by roughly half with minimal downtime.
Designed a Redis caching layer that reduced database query load by 60% and lowered average content serving time from about 200ms to about 80ms.
Implemented monthly active user tracking for the container registry, enabling data-driven product decisions and feature investment.
Maintainer of the GitLab container registry, improving scalability and reliability for enterprise deployments.

Works with Go, PostgreSQL, Redis, Kubernetes, Helm, object storage, AWS, GCP, Azure

Backend Engineer, Go

GitLab · Jan 2020 to May 2022 · Melbourne, remote

Led the migration of GitLab Pages from NFS to object storage, working directly with customers to diagnose and resolve deployment-specific edge cases.
Contributed to the container registry metadata database migration for GitLab.com.
Author and maintainer of release-cli, the tool behind the release keyword in GitLab CI. Maintainer of GitLab Pages.

Works with Go, object storage, GitLab CI, Kubernetes

Senior Software Engineer

Assembly Payments · Jul 2018 to Dec 2019 · Sydney

Built and owned 10 or more microservices and libraries behind Westpac's branded Presto merchant dashboard.
Part of the team that delivered a PCI DSS Level 1 compliant online card payments system.
Built alternative payment solutions for non card transactions.
Championed Go mentoring, upskilling backend and frontend teams and establishing a mentoring programme for juniors and newcomers across offices.

Works with Go, protobuf, gRPC, AWS, GCP, Angular

Senior Software Engineer, Core Services Tech Lead

Spaceship · Jul 2017 to Jul 2018 · Sydney

Owned core services including transactional email over gRPC and AWS SES.
Delivered multiple Go APIs for Spaceship's first and second products.
Built third party integrations across identity verification, fraud screening, messaging, address lookup, CRM and single sign-on.

Works with Go, AWS S3, SES, EC2, ECS and Lambda, Kafka, Docker, Terraform, React

Lead Backend Engineer, then Software Developer

CliniCloud · Mar 2015 to Jul 2017 · Melbourne

Promoted to lead backend engineer after 18 months; managed a small backend and web team working alongside iOS and Android.
Built versions 1 and 2 of the CliniCloud API in Go on a microservices architecture, with full HIPAA compliance for a connected medical device platform.
Executed a services and data migration from AWS to GCP.

Works with Go, AWS, GCP, MySQL, NodeJS, React, container clusters

Earlier

Software Engineer and Validation Engineer, Intel: Jan 2011 to Feb 2014, Guadalajara and Albuquerque. Next generation graphics display module in C++, implementing MIPI and eDP display features. Firmware validation and test automation in Python for Intel solid state drives.
QA Engineer, Cisco Systems: Feb 2011 to Dec 2011, Raleigh and Guadalajara. Video quality testing for the Cisco Cius business tablet on Intel's Moorestown platform. Achieved 100% first pass on schedule.
Intern, Melbourne Networked Society Institute, University of Melbourne: 2015. Built a WebRTC video conferencing system for remote music therapy with quadriplegic patients, in collaboration with the Melbourne Conservatorium of Music.
RFID Lab Intern, HP: 2009 to 2010, Guadalajara. Evaluated RFID chip and hardware performance, tested 17 tags and identified four solutions for HP.

Case studies

Three pieces of work, written up for the constraints rather than the outcome. Everything here is drawn from material GitLab has already published publicly.

Migrating registry metadata off object storage at petabyte scale

ProblemA container registry serving millions of image pulls persisted all of its metadata in object storage. That design limited how efficiently data spanning multiple images could be read, made operations such as tag listing expensive, and left garbage collection as an offline, manual, high-risk activity.

ConstraintsPetabytes of existing metadata. Live traffic across a large multi-tenant SaaS platform plus thousands of independently operated self-hosted installations, each on a different version, a different storage backend and a different orchestration model, whether Linux package or Kubernetes via Helm. Metadata import required a period of read-only time, which made the length of that window the product problem rather than a footnote.

ApproachMoved metadata into PostgreSQL while keeping object storage as the blob layer, so the change was additive rather than a replacement and rollback stayed real. Built import tooling operators could run themselves across both deployment models. Shipped as beta first, in GitLab 16.4, to learn the failure modes from production installations, then hardened to general availability in 17.3.

OutcomeOnline garbage collection with zero downtime became possible, unlocking a class of registry features that legacy metadata storage could not support. Self-managed migration time dropped by roughly half through automation. Storage cost fell around 40% as a second-order effect of the architecture change.

Transferable patternWhen you cannot take the system offline and you cannot control your customers' environments, ship the migration as an operator-run tool with a beta ramp, and keep the new system additive to the old one so rollback remains a real option rather than a slide.

Public reference: container registry metadata database documentation.

Moving a hosted static site platform from NFS to object storage

ProblemGitLab Pages served static sites from NFS. Shared filesystem storage capped horizontal scale, created a single class of failure shared across all tenants, and made the platform expensive to grow.

ConstraintsLive customer sites. No appetite for downtime or broken URLs. A long tail of per-customer edge cases: unusual directory layouts, symlinks, custom domains and configurations accumulated over years that no migration script anticipated.

ApproachMigrated storage to object storage behind a stable serving interface, then worked the long tail directly with affected customers, debugging each case individually rather than assuming the script covered it. Added a caching layer so the extra network hop did not become a latency regression.

OutcomeServing moved off shared filesystem dependency. The caching work cut database query load by around 60% and brought average content serving time from about 200ms to about 80ms.

Transferable patternIn migrations with a long tail, the script gets you to 90% and the remaining 10% is customer engineering, not scripting. Budget for it explicitly or the project stalls at 90% indefinitely.

A quality programme across thirteen engineering groups

ProblemThe bug backlog had grown across a large engineering organisation to the point where severity 1 and 2 issues were aging past their service level objectives, with SLO attainment sitting in the low double digits. No single team owned the problem, which is exactly why it persisted.

ConstraintsNo line authority over the 13 or more groups involved. Each had its own roadmap commitments and its own view of whether the backlog was theirs to fix. Any solution that required sustained heroics would decay the moment attention moved elsewhere.

ApproachMade the data visible and comparable per group, which moved the conversation from opinion to numbers. Set a shared target and a recurring cadence rather than running a one-off push. Removed ambiguity about ownership on each aging issue. Automated the reporting so it ran without manual assembly, which is what made the change durable instead of a quarter-long campaign.

OutcomeA 65% reduction in severity 1 and 2 bugs, a 42% reduction in total product bugs, and SLO attainment up from 10% to 63%.

Transferable patternCross-organisation quality initiatives fail on authority, not on ideas. The lever is comparable per-team data plus a cadence, because that converts a coordination problem into a peer-visibility problem.

Transferable skills

Ranked by how specifically I can prove them, not by how much I enjoy them. Each one is tied to work with a measurable outcome.

Zero-downtime data migration at scale

Moving critical data between storage systems while the system stays live and customers stay unaware.

Proof: petabytes of registry metadata from object storage to PostgreSQL; GitLab Pages from NFS to object storage; AWS to GCP service migration; 50% faster customer migrations through automation.

Cross-organisation programme leadership

Getting many teams that do not report to me aligned on one sequence and holding it as priorities move.

Proof: a quality initiative spanning 13 or more engineering groups; the container registry metadata database rollout across dependent storage, database, infrastructure and frontend teams.

Engineering quality and reliability systems

Turning a bug backlog and unreliable service level objectives into a measured, durable process.

Proof: severity 1 and 2 bugs down 65%, total bugs down 42%, SLO attainment from 10% to 63%.

Cloud cost and storage architecture

Reducing infrastructure spend through architecture rather than vendor negotiation.

Proof: 40% storage cost reduction as a designed outcome of moving metadata into a relational database.

Performance engineering

Finding and removing the real bottleneck in a live distributed system.

Proof: 60% reduction in database query load; content serving from 200ms to 80ms via a Redis caching layer.

Enterprise and self-hosted deployment complexity

Shipping to environments I do not control, on versions and topologies I did not choose.

Proof: Linux package and Kubernetes Helm migration paths; GitLab.com, Self-Managed and Dedicated in parallel; AWS, GCP and Azure.

Remote and asynchronous operating models

Designing how a distributed team plans, decides and stays visible without meetings as the default.

Proof: six years inside one of the most extensively documented all-remote engineering organisations in the industry, latterly designing the delivery process for a stage.

Growing engineers and technical leaders

Moving people from senior individual contributor into leadership, having made that transition myself.

Proof: promoted from backend engineer to engineering manager at GitLab; built a Go mentoring programme across offices at Assembly Payments; led a backend and web team at CliniCloud.

Delivery under audit and regulation

Shipping in environments where the compliance regime constrains the architecture.

Proof: PCI DSS Level 1 card payments platform; HIPAA compliant backend for a connected medical device company.

AI-assisted engineering operations

Building workflows that actually stay in use, rather than demos.

Proof: planning, reporting and automation workflows in production use across an engineering stage, reducing manual coordination overhead.

I move critical data at scale without taking systems down.