Problem Statement: Bloated Images and Slow Builds in Large Applications
Frames the problem as a build-system design question: separation of compile-time dependencies from runtime artifacts, with cache, security, and observability as first-class requirements.
Problem statement
Design a container build system for a large application repository that uses multi-stage Docker builds to produce small, secure runtime images. The naive approach is a single Dockerfile stage that installs compilers, package managers, dev dependencies, test harnesses, and source code into the same image that ships to production. For a large Node, Java, Go, or polyglot monorepo, this produces 1-2 GB images, leaks build tooling and sometimes secrets into production layers, expands the CVE surface, and makes every cold pull slow.
A multi-stage build splits the pipeline into named stages: one stage resolves and caches dependencies, one compiles or bundles, one runs tests, and a final minimal stage copies only the artifacts needed at runtime. Docker 17.05 introduced multi-stage builds in 2017; BuildKit, now the default builder, adds parallel stage execution, cache mounts (RUN --mount=type=cache), secret mounts (RUN --mount=type=secret), and exportable layer caches. This question is not about writing one Dockerfile. It is about designing the build plane: stage contracts, artifact transfer, dependency caching, environment overrides, secret hygiene, build observability, and the CI/CD and registry infrastructure that runs thousands of builds per day.
Why the problem is distinctive
A small service can tolerate a 900 MB image. A large organization cannot, because the cost multiplies across every deploy target: registry storage, network egress, cold-start pull latency on new nodes, scan time, and the number of packages a security team must patch. The build system also sits on the critical path of developer velocity. If a full build takes 35 minutes and runs on every push, thousands of developers serialize behind slow infrastructure. The design therefore separates build correctness from build speed: correctness comes from deterministic stage contracts and pinned artifacts; speed comes from layered caching at four levels (instruction cache, mount cache, external dependency cache, and remote distributed cache).
The four architectural planes
- Source plane: repository layout, lockfiles, and the change-detection logic that decides which images need rebuilding.
- Build plane: Dockerfiles, BuildKit workers, cache backends, secret injection, and test stages.
- Artifact plane: registries, manifests, digests, SBOMs, and provenance attestations.
- Release plane: promotion, scanning gates, deployment, and rollback.
A strong interview answer keeps these planes separate. The build plane never talks directly to production clusters; it emits immutable, content-addressed artifacts that the release plane consumes by digest, never by mutable tag.
Key Highlights
- •Multi-stage builds separate compile-time toolchains from runtime images via FROM ... AS and COPY --from.
- •BuildKit adds parallel stages, cache mounts, secret mounts, and exportable caches on top of classic multi-stage semantics.
- •Image size, CVE surface, pull latency, and registry cost all scale with what leaks from build stages into the final image.
- •Build speed is a caching problem across four levels: instruction cache, mount cache, dependency cache, remote cache.
- •The artifact plane is content-addressed: everything downstream references digests, not mutable tags.
Section Rescue Kit
Buzzwords to use:
Safe statements:
- "I will separate build correctness from build speed before choosing any tooling."
- "Let me define what is allowed to cross the boundary between build stages and the runtime image."