NCA-GENM domain - 15% of the exam

Software Development

Software Development is 15% of the NCA-GENM exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

49
Practice questions
4
Objectives
33
Medium
16
Hard

Where people go wrong

  • Treating a blueprint as one monolithic model

    The wrong answers describe an NVIDIA AI Blueprint as a compiled monolith, a single packaged model binary or a sealed endpoint, then propose forking the source or fine-tuning to change one part. A blueprint is a reference workflow of NIM microservices wired together by configuration. Each model sits behind a standard service API, so an embedding model or a language model endpoint can be swapped or repointed while the retriever and ingestion components stay untouched.

    See it in a sample question
  • Changing a Helm release outside Helm

    The wrong answers fix a release with direct kubectl edits, hand-edited manifests, rollout undo or edits to the shared chart templates. The next helm upgrade reconciles kubectl edits back to the chart and silently reverts them. Hand-applied manifests detach the workload from release tracking, rollout undo leaves Helm's release state pointing at the broken revision, and template edits change the shared chart for every release. The correct answers stay inside Helm: an override values file or --set at upgrade time, or helm rollback to a stored revision.

    See it in a sample question
  • Ordering a migration with init containers or file names

    The wrong answers try to run a migration ahead of the main workload using more replicas, initContainers or file names. Replica count controls scale, and Helm installs resources in a built-in kind-based order, not by filename. An init container runs inside one pod on every start and orders only that pod's containers. A pre-install hook annotation makes Helm apply the migration resource and wait for it before the rest of the release.

    See it in a sample question
  • Swapping the DDPM and DDIM sampler roles

    The wrong answers swap the two samplers' labels, calling DDIM the stochastic sampler and DDPM the deterministic one, or treat the choice as a different training run or a latent versus pixel space question. Both run on the same trained denoiser with no retraining. DDPM ancestral sampling injects fresh noise at each reverse step, while DDIM follows a deterministic, non-Markovian path that can skip timesteps and so needs fewer steps.

    See it in a sample question

Objectives in this domain

Sample questions from this domain

Free sampleSoftware Developmentmedium

A developer wants to swap the embedding model used in an NVIDIA AI Blueprint that implements retrieval-augmented generation. Which structural characteristic of AI Blueprints makes this kind of targeted substitution practical?

  • ABlueprints are structured as reference architectures that wire together discrete NIM microservices, so the embedding NIM can be replaced or reconfigured without rewriting the surrounding pipeline. Correct
  • BBlueprints package all AI logic as a single compiled binary, so the developer recompiles with a different embedding library flag.
  • CBlueprints expose a single REST endpoint that proxies all model calls, so the developer redirects that endpoint to a different embedding service URL.
  • DBlueprints rely on a shared CLIP backbone for all retrieval tasks, so the developer fine-tunes the CLIP model to change embedding behaviour.
Explain why the NIM microservice architecture of AI Blueprints enables component-level customisation without full pipeline rewrites. NVIDIA AI Blueprints are reference architectures that compose multiple NIM microservices into end-to-end workflows. Because each service such as an embedding model, a reranker, or a generative LLM is a discrete, independently addressable unit, a developer can substitute one NIM for another of the same role with minimal impact on the rest of the blueprint. This modular design is the core value proposition of the blueprint approach for customisation.

Why A is correct: An AI Blueprint provides a reference architecture that combines NIM microservices as modular units, meaning any single service such as an embedding model can be swapped independently while the rest of the pipeline remains intact.

Why B is wrong: Blueprints are not compiled monoliths; this misrepresents the composable microservice architecture and confuses it with traditional software packaging.

Why C is wrong: While NIM microservices do expose REST endpoints, the single-proxy description mischaracterises how blueprint components are individually addressed and replaced.

Why D is wrong: CLIP is a vision-language model relevant to multimodal retrieval but is not a universal backbone for all RAG blueprints; this conflates a specific technique with the general blueprint architecture.

Free sampleSoftware Developmenthard

After a helm upgrade rolls out a new conversational AI image, monitoring shows the new pods crash-looping because of a bad model path. The operator wants to return the running release to the exact manifests of the previously working revision using a single Helm operation. Which command achieves this?

  • Ahelm uninstall followed by helm install of the old chart version, which is the only supported way to restore a previous revision's manifests.
  • Bhelm upgrade --reset-values, which discards all accumulated overrides and therefore reverts the release to its last working state.
  • Ckubectl rollout undo on the Deployment, which restores the prior ReplicaSet and keeps Helm's release history synchronised with the change.
  • Dhelm rollback, which redeploys the manifests stored for an earlier release revision and records the rollback itself as a new revision in the release history. Correct
helm rollback redeploys a stored prior revision's manifests as a new revision, restoring known-good state while preserving auditable release history. Helm persists the rendered manifests for every revision of a release, so rollback can reapply an earlier revision verbatim and record the action as a fresh revision, which keeps the cluster state and Helm's history consistent without uninstalling.

Why A is wrong: Tempting because reinstalling clearly produces the old manifests, but it deletes and recreates the release, dropping revision history and risking downtime, and it is not a single operation, so it is not how Helm restores a prior revision.

Why B is wrong: Tempting because resetting values sounds like undoing a change, but --reset-values only clears previously supplied user values back to chart defaults during an upgrade; it does not target a known-good revision and could render a different manifest than the one that worked.

Why C is wrong: Tempting because rollout undo does revert the Deployment's pod template, but it operates outside Helm and leaves Helm's recorded release state pointing at the broken revision, causing drift between the cluster and Helm's history.

Why D is correct: Correct: Helm stores each release revision's rendered manifests, and helm rollback redeploys a prior revision's manifests as the live state, appending a new revision entry so the history stays auditable and forward-only.

Free sampleSoftware Developmenthard

A conversational AI chart packages several Kubernetes resources, including an inference Deployment and a database migration that must run to completion before the application starts. The team wants Helm to run the migration ahead of the main workload during install, and to wait for it to finish first. Which Helm feature expresses this ordering requirement?

  • ASetting a higher replicaCount on the migration pod so that Kubernetes schedules it first and the Deployment waits for those replicas to become ready.
  • BAn initContainer in the inference Deployment that runs the migration, guaranteeing Helm completes the migration once per release before any application pod starts.
  • CA pre-install hook annotation on the migration resource, which tells Helm to apply and wait for that resource before applying the rest of the release. Correct
  • DListing the resources in dependency order inside the templates directory, since Helm applies template files strictly in the alphabetical order of their filenames.
Helm lifecycle hooks such as pre-install run and complete a resource at a defined phase before the main release manifests are applied. Helm recognises hook annotations that bind a resource to a lifecycle event; for a pre-install hook Helm applies the resource and, when configured to wait, blocks until it completes before applying the remaining manifests, which sequences a migration ahead of the application.

Why A is wrong: Tempting because more replicas sounds like higher priority, but replica count controls horizontal scale, not scheduling order, and Kubernetes does not sequence one workload ahead of another based on replica numbers.

Why B is wrong: Tempting because initContainers do run before the main container, but they belong to the pod and run on every pod start rather than once per release, so they do not give Helm a single cross-resource ordering between a migration job and the Deployment.

Why C is correct: Correct: Helm hooks let a resource declare a lifecycle phase such as pre-install, and Helm applies hook resources and waits for their completion before proceeding to the main release manifests, which enforces the migration-before-app ordering.

Why D is wrong: Tempting because Helm does sort resources for installation, but it orders them by a built-in kind-based install order rather than by filename, so renaming files does not let you force a migration to finish before the Deployment.

Free sampleSoftware Developmentmedium

A practitioner contrasts DDPM ancestral sampling with DDIM sampling for the same trained diffusion model. Which statement best captures the conceptual difference between the two samplers?

  • ADDPM requires retraining the denoiser with a cosine schedule, whereas DDIM reuses the existing weights but needs a separate guidance network.
  • BDDPM defines a deterministic reverse mapping while DDIM injects fresh Gaussian noise at every step, making DDPM the faster of the two.
  • CDDPM is a stochastic sampler that adds noise at each reverse step, whereas DDIM follows a deterministic non-Markovian path that allows fewer sampling steps for similar quality. Correct
  • DDDPM and DDIM differ only in the loss function used during training, producing identical sampling trajectories at inference.
Distinguish DDPM stochastic ancestral sampling from DDIM deterministic sampling, which permits fewer steps at comparable quality. DDPM samples a Markovian reverse chain that adds Gaussian noise at every step, whereas DDIM constructs a deterministic non-Markovian process consistent with the same training objective; because the DDIM path is deterministic it can take far larger steps, achieving comparable quality with fewer iterations.

Why A is wrong: Both samplers run on the same trained denoiser without retraining and neither requires a separate guidance network; the claim is tempting because schedules and guidance are real diffusion concerns, but they are not what distinguishes these two samplers.

Why B is wrong: This reverses the actual behaviour: DDPM is the stochastic sampler and DDIM is deterministic; it is plausible to someone who remembers that one is noisy and one is not but has the labels swapped.

Why C is correct: DDPM ancestral sampling injects Gaussian noise each step along a Markovian chain, while DDIM defines a deterministic trajectory that can skip timesteps, so this correctly contrasts stochasticity and step efficiency.

Why D is wrong: Both are inference-time samplers for an identically trained model and produce different trajectories; the statement is tempting as a tidy false equivalence but contradicts the deterministic-versus-stochastic distinction that defines them.

Other domains in this exam

See also the NCA-GENM cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by NVIDIA. Original, blueprint-aligned practice material only.