Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
CI/CD Pipelines · Question Set
Pipeline Design & Configuration interview questions for placements and exams.
Questions
15
Included in this set
Subject
CI/CD Pipelines
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for CI/CD Pipelines.
Stages model the flow. Jobs inside a stage can fan out in parallel, then the next stage runs only when the current one is green. This cuts time and keeps the pipeline easy to read.
stages: [build, test, deploy]
jobs:
build: {}
test_unit: {}
test_int: {}For complete preparation, combine this set with full subject-wise practice for CI/CD Pipelines. You can also explore other subjects and sets from the links below.
Use a cache to reuse things like npm or Maven downloads and avoid repeated network work. Use artifacts to pass built outputs between stages. This split keeps runs fast and results reproducible.
cache: paths: - ~/.m2/repository - node_modules
A matrix multiplies coverage without hand-writing many jobs. It runs the same steps across Node, Java, or OS versions. You catch compatibility issues early while keeping feedback fast.
strategy: matrix: node: [18, 20] os: [ubuntu-latest, windows-latest]
Store secrets in the CI vault or a secret manager. Inject at runtime as environment variables or mounted files. Never commit them to the repo. Scope access with least privilege, mask logs, and rotate keys on a schedule or on exposure.
Extract shared steps into templates or a shared library. Parameterize things like image name, test command, and deploy target. Each repo imports the template and overrides only what is unique. One change improves all pipelines.
uses: org/reusable-workflows/.github/workflows/build-test.yml@v1 with: service_name: payments
Send useful, actionable alerts to the right channel with context. Avoid noisy spam. Good signals speed triage without distracting others.
on_failure: post to #team-payments with build URL
Protect the branch with required checks and approvals. If any check fails, the merge is blocked. This policy keeps main deployable at all times.
Require: build, unit, lint, security to pass before merge
Parallelize independent jobs and reuse downloads or build layers. You keep the same checks but cut wall-clock time and spend. Start with the biggest time sinks for maximum gain.
CI_NODE_TOTAL=4 run-tests --shard $CI_NODE_INDEX/$CI_NODE_TOTAL
Think of it like infrastructure as code, but for delivery. You commit the pipeline file, review it, and track its history. This gives repeatability, easy rollbacks, and the same process across branches and teams.
Jenkinsfile or .github/workflows/ci.yml stored at repo root
Conditions like when, rules, or if statements let you run jobs only for release events. That keeps regular pushes fast and safe.
if: startsWith(github.ref, 'refs/tags/') steps: - run: ./publish.sh
Make deploy idempotent and atomic. Use versioned, immutable artifacts. If a step fails, you can retry without double-deploying. Add clear prechecks and postchecks, and keep a quick rollback path to the last good version.
deploy.sh --version=$ARTIFACT_VERSION healthcheck /ready if fail -> rollback to PREV_VERSION
Guard deploy steps with rules. Build and test can run everywhere, but deployment should gate on main or release branches. This prevents accidental production pushes.
if: github.ref == 'refs/heads/main' steps: - run: ./deploy.sh
Declarative gives you a clear, opinionated structure that teams can read quickly. Scripted lets you program every detail with Groovy, at the cost of complexity. Pick based on team skill and need for control.
pipeline {
stages { stage('Build'){ steps{ sh 'mvn -B package' } } }
}Multi-stage builds keep images small and secure. Caching dependency layers speeds up rebuilds. Never bake secrets into images; inject them at runtime.
FROM node:20 as deps WORKDIR /app COPY package*.json . RUN npm ci COPY . . RUN npm run build FROM node:20-alpine COPY --from=deps /app/dist ./dist
Build once, promote the same artifact forward. Run integration tests in staging, then require an approval or automated checks before prod. Keep environment config externalized so the artifact stays identical across stages.
artifact: app-1.4.2.tgz promote: dev -> staging -> prod