Browse Exams — Mock Exams & Practice Tests

1Z0-1110-25 Syllabus — Learning Objectives by Topic

Learning objectives for OCI 2025 Data Science Professional (1Z0-1110-25), organized by topic with quick links to targeted practice.

Use this syllabus as your source of truth for 1Z0‑1110‑25.

What’s covered

Topic 1: OCI Data Science Service Fundamentals

Practice this topic →

1.1 Core concepts and artifacts

  • Explain the purpose of OCI Data Science and its core artifacts (projects, notebook sessions, jobs, models, deployments).
  • Differentiate notebook sessions vs jobs (interactive vs scheduled) and choose based on workload needs.
  • Identify when to use built-in environments vs custom environments/containers (concept-level).
  • Given a scenario, map a lifecycle stage (explore/train/deploy) to the right OCI Data Science component.
  • Recognize how compartments and tenancy boundaries affect Data Science resource organization and access.
  • Explain how IAM policies govern common Data Science operations (create/read/manage) conceptually.

1.2 Notebook sessions and environments

  • Configure a notebook session (shape, networking) to meet performance and security requirements (concept-level).
  • Given a scenario, choose private networking patterns for notebooks accessing private datasets (concept-level).
  • Explain how dependency management impacts reproducibility across notebook sessions and jobs.
  • Identify safe patterns to persist notebooks and artifacts (Object Storage, Git) without leaking secrets.
  • Given a scenario, troubleshoot common notebook issues (permissions, subnet/DNS reachability) conceptually.
  • Explain how to use Git workflows from notebooks for collaboration and version control.

1.3 Security and access for ML workloads

  • Design least-privilege access for notebooks and jobs using workload identity (dynamic groups/resource principals) conceptually.
  • Given a scenario, use Vault for secrets (API keys, database credentials) and avoid hard-coding sensitive values.
  • Recognize data privacy pitfalls: logging sensitive fields, exporting datasets without access boundaries, and over-sharing artifacts.
  • Explain network segmentation basics for ML workloads (private subnets, controlled egress) conceptually.
  • Given a scenario, choose encryption and key management approaches that meet compliance requirements (concept-level).
  • Describe auditability requirements for ML workflows: logging critical actions, access reviews, and approvals (concept-level).

Topic 2: Data Ingestion, Preparation, and Feature Engineering

Practice this topic →

2.1 Data sources and storage patterns

  • Choose appropriate OCI storage for datasets and artifacts (Object Storage, Block/File) based on access pattern and scale.
  • Given a scenario, design a data landing zone in Object Storage using prefixes, lifecycle policies, and versioning (concept-level).
  • Explain how IAM policies and pre-authenticated access links affect dataset access security (concept-level).
  • Recognize trade-offs between copying data into Object Storage vs accessing data in place (latency, cost, governance).
  • Given a scenario, plan dataset partitioning and formats (CSV vs Parquet) for scalable processing (concept-level).
  • Identify data governance needs (classification, retention, deletion) for ML datasets and derived features.

2.2 Data processing pipelines (batch) on OCI

  • Explain when to use OCI Data Flow (Spark) versus notebook processing for batch feature engineering (concept-level).
  • Given a scenario, design an ETL flow that ingests raw data, cleans it, and writes curated feature datasets.
  • Identify common distributed processing performance considerations (partitioning, shuffles) conceptually.
  • Given a scenario, choose orchestration options to make data prep repeatable (scheduling jobs, pipelines) conceptually.
  • Recognize how to store intermediate artifacts and maintain lineage (Object Storage + metadata) conceptually.
  • Explain how to validate transformations with data quality checks (schema, nulls, ranges) conceptually.

2.3 Feature engineering discipline and data quality

  • Differentiate feature engineering for training vs inference and ensure preprocessing parity (concept-level).
  • Given a scenario, detect and avoid data leakage and label leakage in feature construction.
  • Identify practical approaches to handle missing values, outliers, and categorical encoding.
  • Explain why feature definitions must be versioned and documented to preserve reproducibility.
  • Given a scenario, choose sampling/splitting strategies that respect time ordering and grouping constraints.
  • Define data quality metrics and thresholds that should block training when violated (concept-level).

Topic 3: Training, Experimentation, and Model Lifecycle

Practice this topic →

3.1 Training jobs and compute selection

  • Configure training jobs (shape, CPU/GPU choice, storage) to meet time and cost constraints (concept-level).
  • Given a scenario, choose distributed training approaches when data or model size grows (concept-level).
  • Explain how to package training code and dependencies for repeatable jobs (environments/containers) conceptually.
  • Recognize opportunities to optimize cost (scheduling, scaling down idle resources) for training workflows (concept-level).
  • Given a scenario, choose input/output locations for jobs and manage training artifacts safely.
  • Describe failure handling strategies for training jobs (checkpointing, retries, idempotency) conceptually.

3.2 Experiment tracking and hyperparameter tuning

  • Explain why experiment tracking matters (compare runs, reproduce results) and what metadata should be captured.
  • Given a scenario, design run naming, tagging, and parameter logging to support analysis and governance.
  • Recognize hyperparameter tuning strategies (grid/random/Bayesian) and trade-offs (concept-level).
  • Given a scenario, choose early stopping criteria and evaluation loops that prevent wasted compute.
  • Explain how to manage dataset and code versions alongside experiments to enable reproducibility.
  • Identify common pitfalls: changing preprocessing between runs, tuning on the test set, and uncontrolled randomness.

3.3 Model packaging and portability

  • Describe how to serialize and store models with metadata and dependency information for later reuse.
  • Given a scenario, build a portable inference package that includes preprocessing logic and a stable input schema.
  • Recognize differences between real-time inference packages and batch scoring packages (concept-level).
  • Explain how to capture a model signature (inputs/outputs, types) to prevent serving mismatches.
  • Given a scenario, choose artifact storage and retention policies appropriate for large model files.
  • Identify controls to prevent deploying the wrong artifact or version (approvals, checksums) conceptually.

Topic 4: Evaluation, Responsible AI, and Governance

Practice this topic →

4.1 Evaluation metrics and validation strategy

  • Select appropriate evaluation metrics for classification/regression given business objectives and constraints.
  • Given a scenario, design validation that avoids leakage (holdout strategy, time-based splits, cross-validation).
  • Explain how to interpret confusion matrices, ROC/PR curves, and threshold trade-offs at a practical level.
  • Recognize the difference between offline evaluation and online performance monitoring (concept-level).
  • Given a scenario, decide whether a model meets acceptance criteria (accuracy, stability, fairness) before promotion.
  • Identify common evaluation mistakes: tuning on test data, ignoring imbalance, and using the wrong baseline.

4.2 Model governance and registry workflows

  • Explain the purpose of a model registry and what to record (versions, metrics, lineage, owners).
  • Given a scenario, design a promotion workflow (dev → staging → prod) with approvals and auditability (concept-level).
  • Recognize governance requirements: reproducibility, traceability, and least-privilege access controls.
  • Describe how versioning enables rollback and supports incident response for ML deployments (concept-level).
  • Given a scenario, define metadata standards (tags, risk classification) for managing many models at scale.
  • Identify safe processes for model deprecation and retirement to avoid breaking downstream consumers.

4.3 Responsible AI, security, and privacy (concept-level)

  • Recognize common sources of bias and how to test fairness across slices (concept-level).
  • Given a scenario, choose privacy-preserving approaches (minimization, anonymization) for datasets and outputs.
  • Explain why security threats apply to ML systems (prompt/data injection, exfiltration) at a conceptual level.
  • Identify security controls for ML workloads: least privilege, network isolation, and secret management.
  • Given a scenario, define documentation and disclosures needed for regulated model use (concept-level).
  • Recognize when human review and escalation paths are required for high-risk model decisions (concept-level).

Topic 5: Deployment and Inference on OCI

Practice this topic →

5.1 Managed deployments and endpoints

  • Explain managed deployment concepts: endpoints, replicas, scaling, and networking for inference services (concept-level).
  • Given a scenario, choose public vs private endpoints and configure access controls appropriately.
  • Identify patterns to package inference code with preprocessing and postprocessing logic safely.
  • Given a scenario, design request/response schemas and enforce validation to reduce runtime errors.
  • Recognize common serving bottlenecks (cold starts, concurrency limits) and mitigations (concept-level).
  • Explain how to integrate model endpoints with API management (API Gateway) conceptually.

5.2 Rollouts, scaling, and reliability

  • Design rollout strategies (canary, blue/green, shadow) to reduce deployment risk and validate behavior.
  • Given a scenario, choose autoscaling signals (latency, CPU) and safe minimum capacity settings (concept-level).
  • Explain how health checks and circuit breakers reduce customer impact during partial failures (concept-level).
  • Recognize high-availability considerations (multi-AD, multi-region patterns) for critical inference workloads (concept-level).
  • Given a scenario, plan rollback triggers and procedures based on error rate and quality signals.
  • Identify test strategies (smoke tests, regression suites) that validate model and preprocessing changes before full rollout.

5.3 Event-driven and batch inference patterns

  • Differentiate synchronous API inference vs asynchronous batch scoring and choose based on latency and throughput needs.
  • Given a scenario, design an event-driven scoring pipeline using events/queues/functions conceptually.
  • Explain how to write inference results back to data stores with idempotency and safe retries (concept-level).
  • Recognize where to add observability signals: structured logs, metrics, and traces (concept-level).
  • Given a scenario, choose a pattern that isolates failures and supports backpressure and retries.
  • Identify cost/performance trade-offs between batch windows and always-on real-time endpoints.

Topic 6: MLOps Operations, Monitoring, and Cost

Practice this topic →

6.1 Monitoring quality, drift, and performance

  • Define production ML monitoring signals: latency, errors, throughput, drift, and data quality (concept-level).
  • Given a scenario, choose metrics and dashboards that detect regressions quickly and reflect user impact.
  • Explain how to set alert thresholds that reduce noise and focus on actionable conditions.
  • Recognize drift detection techniques and when to trigger retraining (concept-level).
  • Given a scenario, design logging that preserves privacy while enabling debugging and auditability.
  • Identify incident response steps for ML issues (rollback, disable model, hotfix features) conceptually.

6.2 Automation, CI/CD, and IaC for ML systems

  • Explain why ML systems benefit from end-to-end automation with versioned infrastructure and code.
  • Given a scenario, design CI checks for data/feature code and evaluation gates before promotion (concept-level).
  • Recognize how IaC (Terraform/Resource Manager) supports repeatable environments and reduces drift.
  • Given a scenario, choose safe automation for scheduling retraining and promoting deployments with approvals.
  • Explain how environment separation reduces risk and simplifies rollback for ML services (concept-level).
  • Identify audit and approval controls required for automated releases in regulated settings (concept-level).

6.3 Cost management and lifecycle management

  • Identify main cost drivers for ML workloads (compute, storage, data transfer) and practical optimization levers.
  • Given a scenario, choose scheduling and rightsizing approaches to control spend (stop idle notebooks, scale down).
  • Explain how lifecycle policies and retention reduce artifact sprawl in Object Storage.
  • Recognize trade-offs between keeping every experiment artifact vs pruning with governance controls.
  • Given a scenario, plan a model lifecycle that includes retraining cadence, ownership, and retirement steps.
  • Explain how runbooks and operational ownership (on-call, SLAs) improve reliability and reduce repeated incidents (concept-level).
Study Plan
Cheat Sheet