The Foundation Model Lifecycle: Data Selection to Deployment, in Order

The foundation model (FM) lifecycle is the ordered sequence a generative AI model moves through from raw data to a running application: data selection, model selection, pre-training, fine-tuning, evaluation, deployment, and feedback. The order matters — you cannot fine-tune a model that has not been pre-trained, and you should not deploy one that has not been evaluated — and the AIF-C01 exam tests both the sequence itself and what happens inside each stage.

The seven stages, in order

AWS teaches the lifecycle as a pipeline with a feedback loop at the end. Here is the canonical ordering with the purpose of each stage:

Order	Stage	What happens	Output
1	Data selection	Gather and curate the massive, diverse corpus the model will learn from; filter quality and remove harmful or duplicate content	Training corpus
2	Model selection	Choose the architecture and scale (or an existing base model) suited to the goal	Model design / base model
3	Pre-training	Train on the broad corpus with self-supervised learning to build general capability	Base foundation model
4	Fine-tuning	Further train the base model on a smaller, task- or domain-specific dataset	Specialized model variant
5	Evaluation	Test against benchmarks, human review, and business criteria; compare candidates	Go/no-go evidence
6	Deployment	Serve the model behind an API or application for real users	Production endpoint
7	Feedback (monitoring)	Watch quality, drift, cost, and user signals in production; feed findings back into earlier stages	Continuous improvement

Two ordering facts are tested constantly: data selection and pre-training both happen before fine-tuning (so does model selection), and evaluation happens before deployment. If a question asks which stages precede fine-tuning, the safe picks are data selection and pre-training.

Stage 1–2: data selection and model selection

Everything downstream inherits the quality of the training corpus. Data selection for an FM means assembling text, code, and other content at web scale, then curating it: deduplicating, filtering low-quality and toxic material, balancing sources, and respecting licensing. Biases baked in here surface later as biased outputs, which is why responsible-AI reviews reach all the way back to this stage.

Model selection then fixes the shape of what you will train: the architecture (transformers dominate), the parameter count, and the compute budget. For most organizations — who adapt rather than build FMs — “model selection” in practice means choosing an existing base model, a decision process detailed in how to choose a foundation model.

Stage 3: pre-training — where general capability is built

Pre-training is the defining stage of the lifecycle: the model trains on the vast, largely unlabeled corpus using self-supervised learning, most commonly by predicting the next token and learning from its errors across trillions of examples. No human labels the data; the text itself supplies the supervision signal. Over weeks of training on large GPU or AWS Trainium clusters, the model acquires general language ability, world knowledge, and reasoning patterns.

The exam wants a crisp answer for “what happens during pre-training”: the model learns general patterns and representations from massive unlabeled data via self-supervision — building broad capability before any task-specific specialization. Pre-training is the most expensive stage by far, which is why it is done once by a model provider and reused by everyone downstream.

Stage 4: fine-tuning — specialization on top

Fine-tuning takes the already-capable base model and continues training on a much smaller, curated, typically labeled dataset — your support transcripts, your legal domain documents, your preferred response style. The weights shift modestly toward the target domain while retaining general ability. Variants include instruction tuning (training on prompt-response pairs) and Reinforcement Learning from Human Feedback (RLHF) for aligning behavior with human preferences. Fine-tuning is optional — prompt engineering or Retrieval-Augmented Generation (RAG) may be enough — but when it is used, it always sits after pre-training in the lifecycle. Preparing that dataset well is its own discipline, covered in fine-tuning data preparation.

Stage 5: evaluation — prove it before you ship it

Evaluation answers whether the model is good enough for the intended use. It blends automated benchmarks (for language tasks: metrics such as ROUGE for summarization or BLEU for translation, plus broad benchmarks like MMLU), human evaluation for subjective quality, and business-specific tests for accuracy, safety, and tone. On AWS, Amazon Bedrock offers model evaluation jobs (automatic and human-based) to compare candidate FMs. Evaluation gates deployment: a model that fails here loops back to fine-tuning or data work, not forward to production.

Stages 6–7: deployment and feedback

Deployment puts the model behind a production interface — an Amazon Bedrock API call, an Amazon SageMaker endpoint, or an application layer — with attention to latency, throughput, scaling, and cost. The lifecycle does not end at launch. The feedback stage monitors production behavior: response quality, hallucination reports, drift as real-world inputs shift, token costs, and user satisfaction. Those signals flow back into earlier stages — new fine-tuning data, refreshed evaluations, sometimes a different base model — making the lifecycle a loop rather than a straight line. This mirrors the monitoring discipline of traditional MLOps, applied to generative models.

How the AIF-C01 exam tests this

Lifecycle questions belong to the Fundamentals of Generative AI domain; see the full AIF-C01 study guide for the complete domain breakdown and question formats — then drill the sequence with practice questions until you can recite it cold.

• Ordering questions (including drag-and-drop style). You arrange the stages first-to-last. Anchor on the spine: data selection → model selection → pre-training → fine-tuning → evaluation → deployment → feedback.
• “Which stages come before X?” questions. Typically before fine-tuning: data selection, model selection, and pre-training all qualify; distractors offer evaluation, deployment, or feedback, which come after.
• Stage-definition questions. “What happens during pre-training?” — self-supervised learning of general patterns from massive unlabeled data. Distractors describe fine-tuning (small labeled dataset), evaluation (benchmark testing), or deployment.
• Loop-awareness scenarios. A deployed model degrades or receives poor user feedback; the credited response routes monitoring insights back into fine-tuning data or re-evaluation rather than treating deployment as final.

Quick reference

• Lifecycle order: data selection → model selection → pre-training → fine-tuning → evaluation → deployment → feedback.
• Pre-training = self-supervised learning on massive unlabeled data; builds general capability; the most expensive stage.
• Fine-tuning = continued training on a small task-specific dataset; always after pre-training; optional if prompts or RAG suffice.
• Before fine-tuning: data selection, model selection, pre-training. After it: evaluation, deployment, feedback.
• Evaluation gates deployment — benchmarks plus human review plus business criteria; Amazon Bedrock provides model evaluation jobs.
• Feedback/monitoring closes the loop: production signals drive new data, new fine-tunes, and re-evaluation.
• Data quality decisions at stage 1 propagate everywhere — bias in the corpus becomes bias in the outputs.