Every training officer faces the same budget meeting: which aircraft and which simulators should the academy fly this year, and for which lessons? Flight schools answer it by matching the machine to the mission — the simple trainer for early circuits, the glass-cockpit twin for advanced work, the simulator for procedures that would be reckless in the sky. Teams that run delivery on GitLab face an identical procurement question about their executor fleet, and answering it well is one of the central skills of GitLabOps, the Ops Atlas’s working name for operating delivery on the platform. Here is the comparison, stated the way a training officer would: capability, cost, risk, and the mission each machine actually serves.

First, What a GitLabOps Executor Decides

When a pipeline job leaves the queue, something must actually run it — a machine, in a chosen mode, with a chosen blast radius. That choice is the executor. It sets three things at once: how isolated the work is from its surroundings, what each job costs you in machines or fees, and how quickly the fleet can grow or shrink. Choose wrongly and the symptoms are familiar: environments polluted by yesterday’s test run, a bill that climbs with every merge, or jobs that cannot start because the one capable machine is busy. Choose well and the fleet fades into the background, which is exactly where infrastructure belongs.

The Contenders, One by One

The instructor’s own aircraft: shell

The shell executor runs jobs directly on the runner machine itself, no separation. It is the academy’s own aircraft: zero rental overhead, immediate start, total exposure. One careless student — or one malicious contribution — touches everything the machine can reach. The training-world verdict applies verbatim: suitable only for trusted pilots. In platform terms, never point a shell executor at untrusted code, and treat any you keep as though the whole hangar rides on its discipline.

The standard trainer: Docker

The Docker executor gives every job its own fresh container: a clean cockpit each sortie, wiped on exit. Isolation is good, start-up cost is small, and the model suits the bulk of everyday work — tests, builds, checks. It is the reliable trainer that flies most of the school’s hours. Its one trap is shared machinery: a single, always-privileged build pool that every project borrows concentrates risk badly. Keep the privileged machinery out of general circulation and the Docker path stays dependable.

The weather-on-demand fleet: autoscaling Docker

An autoscaling Docker arrangement spins machine capacity up when the queue deepens and lets it go when the hangar empties. For academies this is the simulator analogy done properly: book capacity when the lesson needs it, release it when done. It handles bursty demand — the Monday-morning rush of merge requests — better than a fixed fleet. Its weakness is standing cost and plumbing: cloud instances, images, and network paths all need someone on duty who understands them.

The airline-pathway rig: Kubernetes

Running jobs as workloads inside Kubernetes suits teams whose applications already live there — one scheduling brain, dense packing, mature tooling. It looks like the career path to airline-style sophistication, and sometimes it is. But the assumption that it is automatically cheaper does not survive contact with an invoice: cluster overhead, idle capacity, and operational attention are real costs, and for many small fleets a plain autoscaling setup beats it on price. Choose it because your platform already lives there, not because the logo sounds senior. Sophistication that arrives before the need is just expense wearing a uniform.

The chartered block booking: hosted runners

Hosted runners are capacity someone else owns, maintains, and isolates per job. You trade control for the disappearance of an entire operations chore list: no fleet to patch, no images to curate, no capacity forecasts. For small teams this is often the sanest first answer, and the trade can flip back as needs mature.

Mixed Fleets Beat Favorites

Real academies do not standardize on one airframe, and mature platform teams do not either. The workable pattern is segmentation by trust and by task: everyday build-and-test work on fresh containers, anything touching third-party contributions on machines used exactly once, dense platform workloads where a cluster already exists, and rented hosted capacity wherever nobody wants to own the plumbing. Segmentation is also a security posture, not just an accounting one — the machine an untrusted pull request touches should never be the machine that also holds deployment credentials. Write the segmentation down as policy so the next hire does not accidentally reunify the fleet under one convenient label. Fleet documents age like aircraft logs, too — the schools that add a glass-cockpit twin to the training fleet update the syllabus the same week, and platform teams should update their executor policy the week the fleet changes.

Scoring a GitLabOps Fleet Like a Procurement File

The Atlas’s worked example is worth retelling because of how ordinary it is. A team scored its runner arrangement — autoscaling cloud machines versus rented hosted capacity — and the autoscaling setup won on raw flexibility, a 3.85 against 4.30 in reverse; then its private-network requirement vanished, the weights changed, and the hosted option moved ahead, taking the decision with it. The lesson is not the numbers. It is that executor choice is a scored decision against requirements, and requirements move. Re-score when the mission changes, not when a fashionable blog post lands.

Two more readings keep the scoring honest. Measure fleet saturation — how much of the hour the fleet is actually flying — before buying anything, because an idle fleet needs reassignment, not expansion. And price per successful pipeline rather than per job; a cheap run that fails twice costs more than the expensive run that lands once.

Hangar-Rash Mistakes Worth Naming

  • One shared, privileged build pool for the entire organization — the mechanical equivalent of letting every student fly the only aircraft with the fuel-truck keys.
  • Shell executors pointed at code from outside the team — no instructor would authorize it, and neither should a platform owner.
  • Assuming the Kubernetes route pays for itself — check saturation and cost per successful pipeline before committing.
  • Buying machines to fix a queue that tags, not capacity, is strangling.

Flight academies that want to see how real schools stage their fleet upgrades can read this site’s notes on the FRASCA 142 simulator added for IFR procedure work and the the Academy’s ALSIM selection for instrument, proficiency, and upset work — both are the same decision discipline: capability needed, risk contained, then money spent. The Atlas’s GitLabOps reference applies the identical arithmetic to runner fleets, with the scoring sheet included. Match the machine to the mission, review the scorecard when the mission moves, and the fleet question answers itself — for hangars and for pipelines alike.

© 2024 ADVANCED INTERNATIONAL AVIATION ACADEMY. ALL RIGHTS RESERVED.

STAY CONNECTED WITH US: