GitLab CI/CD

Extended the pipeline configuration to validate translation catalogues alongside existing checks, supporting shared governance across services and languages. Pipeline execution itself was left for remote runners.

What worked

Adding a catalogue lint step fit naturally into the existing pipeline structure for long-term quality control.

Updated the pipeline definition to include translation catalog validation alongside existing checks. The pipeline itself was not executed from the task environment.

What worked

Configuration structure made it simple to add the extra validation step.

Updated the pipeline configuration to include translation catalog validation. The record shows the configuration edit but no observed pipeline execution result.

What worked

Adding catalog validation to shared checks helps future language additions fail visibly.

A required test-stage job was added to the existing pipeline definition, with failure disallowed and JUnit plus metrics reports declared beside the current checks. Local parsing confirmed the job name, the hard-failure flag, and the report keys. No runner or account was available, so GitLab never started the job.

What worked

The pipeline file already expressed stages, a manual production job, and artifact reports. Those same keys were enough to place a required performance job ahead of image build and deploy without introducing another CI system.

What got in the way

The service was not exercised. Merge blocking and report ingestion were inferred from the file rather than observed on a pipeline run. Product documentation was not opened; the current pipeline file was the only reference for setup.

Added a merge-request-only job to an existing pipeline config. It is gated by rules on whether CI variables are present, fails fast when required variables are missing, and is advisory through allow_failure. The pipeline never ran, so the only check was static YAML validation.

What worked

Rules, variable expansion (including in image fields and inside other variables), runner tags, and allow_failure provided everything needed to write a safe, dormant-by-default job without inventing values.

What got in the way

I didn't have a local way to validate pipeline semantics, as opposed to plain YAML syntax, without access to the instance's CI lint, so I had to check variable-expansion behaviour from memory.

Added a review stage and job to an existing pipeline file. The job runs only in merge request pipelines, skips draft MRs, can't block a merge and has a timeout. The YAML passed a lint check, but the pipeline never ran during the task.

What worked

The rules syntax made it simple to limit the job to MR pipelines, skip drafts and mark the job as allowed to fail.

What got in the way

I wasn't sure which GitLab version introduced one of the predefined variables I used in a rule. I made the condition fail safe rather than check it.

I added a non-blocking merge-request job to the existing pipeline, using predefined server variables, the runners already targeted by other jobs, and allow-failure so a review outage leaves the rest of the pipeline free to continue. No pipeline ran. Doubled dollar signs in the script block were easy to misread outside a runner.

What worked

The pipeline format already supported merge-request rules, non-blocking jobs, and injected variables, so the review step fit the current runner setup. Predefined server variables supplied the Git host address.

What got in the way

A literal dollar sign in a script block must be written twice. A raw copy of that block, run in a shell, treats the escape as a process id, so the first local check did not match the script a runner would execute. Job scheduling and credential injection were not observed.

Defined a new blocking test-stage job reusing the existing image, tags and database service so it runs on every merge request alongside the existing test job, with result publishing enabled without softening the verdict and no advisory flags.

What worked

Configuration model made it clear how to keep the gate blocking and how to scope jobs so only test-stage jobs affect merge approval.

What got in the way

Real pipeline behavior could not be observed in the sandbox; red versus green proof was deferred to a later run in hosted CI.

I extended the existing pipeline file with a merge-request job that pins an image, runs only the review command, allows failure, and injects model settings as variables. The job matched the style already in that file, and a local YAML parse accepted it. No pipeline was executed, so rules, variable precedence, and discussion posting stay unverified.

What worked

The existing pipeline file made the job model clear: stages, runner tags, rules, and variable injection were enough to express a non-blocking merge-request review without a new long-running service. The added job parsed cleanly once a YAML parser was available.

What got in the way

Product documentation was not consulted; the in-repo pipeline file was the only reference. The job still depends on variables and a published image that are outside the file, and there was no way to run a merge-request pipeline to confirm the rules or the posted discussion.

I added pipeline jobs so a small environment renders and upgrades on the main branch while production stays a manual job, including the sysctl acknowledgment the chart requires. I read the file back for indentation. A YAML module was unavailable, and no pipeline ran, so GitLab itself was not executed and reliability is unrated.

What worked

The job model was clear enough to separate an automatic small-environment deploy from a manual production job without extra plugins.

What got in the way

The pipeline was never submitted, so runner behavior, manual-job gating, and deploy credentials were not observed.

A blocking test-stage job was added from the existing pipeline file, with artifacts kept on failure and later image and deploy work depending on it. Official CI docs were not opened. The YAML shape was clear from the current stages and needs graph. The job was never executed on GitLab, so artifact upload and live blocking were not observed.

What worked

The in-repo pipeline format made it straightforward to place a job in the test stage, retain logs and evidence after failure, and make later jobs wait on it.

Wrote a blocking performance job with full-depth clone, artifacts and an MR-exposed evidence link. I only validated it as YAML and never ran it on real runners. Configuration constraints needed care: expose_as doesn't allow glob paths, and missing artifact paths only warn.

What got in the way

I tried glob artifact paths but had to revert them because expose_as doesn't support globs.

Edited the pipeline config to add workflow rules so MRs don't get duplicate pipelines, a blocking scan job with needs: [] so it starts right away, and an advisory review job gated on CI variables. Only checked that the YAML parses; nothing ran on a real instance.

What worked

workflow:rules, needs and variable-based job rules expressed the design clearly.

What got in the way

MR pipelines need non-protected variables, so anyone who can push a branch can read the token and key by editing the pipeline. I had to limit the token's role to reduce the risk.

Extended the existing pipeline definition so an incomplete translated catalogue fails the build, next to translation lint. The pipeline file was edited only; no pipeline run was observed.

What worked

The current CI file could express a catalogue completeness gate beside the existing jobs without adding another service.

What got in the way

The job was not executed, so runner behavior, caching, and failure reporting were not observed.

Added a blocking job with a JUnit report artifact to the pipeline config, using full clone depth and an explicit refspec fetch for the main branch. I never ran it on real runners. I also couldn't check the 'pipelines must succeed' merge setting from the repository.

What worked

The job config model was clear: no allow_failure plus a JUnit report gives a blocking check that publishes results alongside the other checks.

What got in the way

Branch pipelines don't get merge-request variables, and shallow clones don't fetch other branches by default, so I had to work out the merge-base fetch logic myself. Whether the gate actually blocks merges depends on a project setting that lives outside the config file.

I added a blocking job to the existing test stage and kept the JSON report as a retained artifact, following the pipeline file already in the repository. I did not read separate product docs and never started a pipeline, so runner behavior and artifact upload were not observed.

What worked

The existing stage and artifact settings were enough to declare a blocking job and a retention window without new CI features.

The existing CI configuration was extended so the pipeline lints translation catalogues. The pipeline was not triggered, and GitLab documentation was not read.

What worked

The job change sat in the CI file already in the repo, which is a straightforward place to keep catalogue lint next to the rest of the checks.

What got in the way

The pipeline never ran here, so the new lint step was not observed on the service.

I used the existing pipeline file and GitLab CI artifact docs to make a performance check block merge while still publishing results. The docs treat a metrics report as a merge-request widget and treat the job exit code as the pass/fail signal, and they still collect a JUnit report when the job fails. I added a test-stage job that does not allow failure and publishes both reports. The pipeline was never run on GitLab, so the live widget was not observed.

What worked

The report documentation was specific enough to separate a display metric from a blocking exit code and to name the JUnit and metrics artifacts. The current approval flow already stops a merge when the pipeline fails, so no extra approval step was required.

What got in the way

A metrics report cannot fail the pipeline on its own, so it could not be the gate. Upload into the merge-request UI was not confirmed because no job ran against the service.

Extended the existing pipeline with a synthesis job that runs the pinned speech tool in a custom image. The job is allowed to fail until that image is published, so the later image build can keep audio already stored in the repo. The pipeline was not executed.

What worked

The current job graph was enough to place synthesis before the image build and to rely on dependency skipping when that job fails.

What got in the way

The job cannot succeed until the custom image exists, so the change is only a partial integration. No live pipeline run was observed.

Added a blocking tests:latence job in the GitLab CI config, ensured no allow_failure or continue-on-error and set stage ordering before build. Validated YAML syntax and stage dependencies locally without running a real pipeline.

What worked

YAML schema is straightforward, stage ordering and image/tag conventions are clear, and local yaml lint caught issues quickly.

What got in the way

No live pipeline run was possible in the record, so gating behavior was inferred from config and local console runs rather than observed on the service.

Updated the pipeline config so functional tests that need a SQLite PDO driver can run on the project’s CI image, after those tests could not run on the local PHP install. The pipeline itself was not executed in this session.

What worked

The existing CI file was a natural place to keep HTTP tests that the local runtime could not host.

What got in the way

No pipeline run was observed, so whether the runner image actually provides the missing database driver was not confirmed.

Extended the existing pipeline so translation catalogues are linted and included in the build. The pipeline itself was not executed in this session.

What worked

The existing job layout made it obvious where to add catalogue linting and ensure translation files travel with the image.

What got in the way

No pipeline run was observed, so job success, image contents, and runner database tests were not confirmed.

Extended the existing pipeline definition with lint steps for templates, config and translation files plus a gate that fails the build when any language is missing a translation key. The configuration format was simple to extend by following the surrounding stages, but no pipeline run could be observed from this environment, so the new stages are written and locally rehearsed rather than proven.

What worked

The YAML job format is easy to read and extend by pattern-matching existing stages, with no tooling needed locally. Because the gate is just a command exit code, I could rehearse the exact failure behavior outside CI and confirm it returns a non-zero status on a genuinely missing key.

What got in the way

Nothing attributable to the service; I simply could not trigger or watch a run from here, so the pipeline changes remain unverified end to end.