Oracle 1z0-1084-26 Real Exam Dumps [September 2026 Update]

Two domains – Cloud Native Applications and Containerization at 33% and Leveraging Serverless Technologies at 33% – account for two-thirds of the 1Z0-1084-26 exam. This weighting is confirmed by multiple independent sources. The implication for preparation is clear: any candidate who cannot confidently answer OKE cluster configuration questions and Oracle Functions deployment questions has already put two-thirds of their exam score at risk before they open the testing interface. The more important preparation caveat is that OCI-general knowledge is not the same as OCI-specific knowledge. A developer who has worked with Docker, Kubernetes, and serverless architectures on AWS, Azure, or GCP has the conceptual foundation – but the exam tests Oracle-specific implementations: OCI Container Engine for Kubernetes has specific node pool configurations, OCI-specific networking modes (VCN-native pod networking), and OCI Load Balancer integration behavior that differ from how other Kubernetes managed services work. Oracle Functions is built on the open-source Fn Project serverless platform – knowing that OCI Functions uses Fn Project, how function configuration (memory, timeout, concurrency) interacts with Fn’s execution model, and how Oracle Functions integrates with OCI Events as triggers is OCI-specific knowledge that does not transfer from AWS Lambda familiarity. The exam is not testing whether you understand serverless concepts in the abstract. It is testing whether you can configure and troubleshoot Oracle-specific implementations in OCI-specific scenarios.

The Oracle 1Z0-1084-26 (Oracle Cloud Infrastructure 2026 Developer Professional) validates the ability to design, build, and deploy cloud-native applications on OCI using containerization, serverless, and event-driven architectures. $245. Approximately 55-60 questions in 90 minutes, approximately 65% passing. The exam requires hands-on OCI developer experience – conceptual knowledge alone is not sufficient.

Cert Empire’s 1Z0-1084-26 exam questions cover all five domains at OCI-specific implementation depth – not general cloud-native concepts but Oracle Functions, OKE, OCIR, and OCI API Gateway configuration scenarios.

Exam Snapshot

Five Domain Weights

Domain 1: Cloud Native Fundamentals (~9%)

Cloud-native principles: Cloud-native applications are designed to take full advantage of cloud infrastructure through containerization, microservices architecture, dynamic scaling, and automation. The exam tests the twelve-factor app methodology as the foundational design guide for cloud-native applications:

• Codebase: One codebase tracked in version control, many deploys.
• Dependencies: Explicitly declare and isolate dependencies.
• Config: Store configuration in the environment, not in code.
• Backing services: Treat backing services (databases, message queues) as attached resources.
• Build, release, run: Strictly separate build and run stages.
• Processes: Execute the app as stateless, share-nothing processes.

The exam tests which twelve-factor principle is violated by a described application characteristic – for example, an application that reads database credentials from a config file checked into version control violates the Config factor.

Microservices vs. monolithic architecture: Microservices decompose an application into small, independently deployable services each responsible for a specific business capability. The exam tests the trade-offs: microservices enable independent scaling and deployment of individual services but add complexity (service discovery, network latency between services, distributed tracing). Monolithic architectures are simpler to develop initially but create deployment coupling – a change to any component requires redeploying the entire application.

Domain 2: Cloud Native Applications and Containerization (~33%)

Docker and Container Fundamentals

Container images and Dockerfiles: A Dockerfile defines the instructions for building a container image. The exam tests key Dockerfile instructions: FROM (base image), RUN (execute commands during image build), COPY and ADD (add files to the image), ENV (set environment variables), EXPOSE (document which port the container listens on – does not actually publish), CMD and ENTRYPOINT (define what runs when the container starts). The exam tests multi-stage builds – using multiple FROM instructions to separate build-time dependencies from the final minimal runtime image, reducing image size.

OCI Container Registry (OCIR): OCIR is Oracle’s managed container image registry. Images are stored in repositories within OCIR and identified by path: <region-code>.ocir.io/<tenancy-namespace>/<repository-name>:<tag>. The exam tests OCIR authentication (an OCI auth token – not a password – is used as the password for Docker login), pushing and pulling images (docker push and docker pull with the full OCIR path), and image scanning (OCIR can scan images for known vulnerabilities, producing a vulnerability report before deployment).

OCI Container Engine for Kubernetes (OKE)

What OKE provides: OKE is Oracle’s managed Kubernetes service. Oracle manages the Kubernetes control plane (API server, etcd, scheduler, controller manager) – the customer does not need to provision or maintain control plane nodes. The customer manages worker nodes (compute instances where application pods run) through node pools.

Cluster network types the exam tests:

VCN-Native Pod Networking (the default recommended approach for new OKE clusters): Each pod receives an IP address directly from the VCN subnet – pods are first-class citizens of the VCN network. This enables direct communication with other OCI services and on-premises networks without NAT. Pod IP addresses are visible within the VCN.

Flannel networking (older approach): Pod IP addresses are managed by Flannel inside the Kubernetes cluster and are not visible to the broader VCN. Simpler to configure for isolated Kubernetes workloads.

The exam tests when VCN-Native is preferred (when pods need to communicate with non-Kubernetes OCI resources or require VCN-level visibility) versus Flannel (simpler environments without cross-service pod communication requirements).

Node pools: OKE organizes worker nodes into node pools – groups of identically configured compute instances. The exam tests node pool configuration: selecting the compute shape (which OCI compute shape each worker node uses), selecting the image (the OS image for worker nodes – OKE-optimized Oracle Linux images), and setting the number of nodes. Multiple node pools can exist in one cluster (for example, a general-purpose pool and a GPU pool for AI workloads).

Kubernetes workload types the exam tests:

Deployments: Manage stateless application pods with a desired replica count. If a pod fails, the Deployment controller creates a replacement. Used for web servers, API services, stateless microservices.

StatefulSets: Manage stateful applications that require stable network identities and persistent storage (databases, message queues). Each pod has a persistent identity and stable persistent volume.

DaemonSets: Run one pod on every node in the cluster (or a subset). Used for cluster-level services like log collection agents, monitoring agents, or network plugins.

OCI Load Balancer integration with OKE: When a Kubernetes Service of type LoadBalancer is created in OKE, OKE automatically provisions an OCI Load Balancer (or Network Load Balancer) and configures it to forward traffic to the service’s pods. The exam tests what the annotation service.beta.kubernetes.io/oci-load-balancer-shape controls (specifying the Load Balancer shape and bandwidth) and how to create an internal load balancer (annotations to provision a private load balancer without a public IP).

OCI Service Mesh: OCI Service Mesh provides traffic management, security (mutual TLS between services), and observability for microservices running in OKE without requiring code changes in each service. The exam tests the Service Mesh components: virtual deployments (abstract a specific version of a service), virtual services (represent the logical service), and ingress gateway (the entry point for external traffic into the mesh).

Domain 3: Leveraging Serverless Technologies (~33%)

Oracle Functions

Oracle Functions and the Fn Project: Oracle Functions is OCI’s managed serverless compute service, built on the open-source Fn Project serverless platform. The Fn Project defines: the function (a unit of code that executes in response to invocations), the application (a group of functions sharing configuration), and the FDK (Function Development Kit – language-specific libraries for writing Fn-compatible functions in Python, Java, Node.js, Go, Ruby, and others).

Function configuration the exam tests:

Memory: The amount of memory allocated to the function execution environment (128 MB to 2048 MB). Higher memory also provides proportionally more CPU.

Timeout: The maximum execution duration (1 second to 300 seconds). Functions that exceed the timeout are terminated.

Concurrency: OCI Functions scales by launching multiple concurrent function instances. The exam tests that each function invocation runs in an isolated execution environment – state does not persist between invocations in the execution environment (data persistence requires an external store like OCI Object Storage or Autonomous Database).

Cold starts: The first invocation of a function after a period of inactivity requires initializing a new execution environment – the container must be started, the runtime initialized, and the function code loaded. Subsequent invocations within the warm window reuse the existing environment (warm start). The exam tests what causes cold starts (inactivity period, new container deployment, or concurrency scale-out) and how to mitigate cold start impact for latency-sensitive applications (provisioned concurrency maintains pre-initialized environments).

Function invocation methods: Functions can be invoked by: direct HTTP invocation through the OCI Functions API, OCI Events (a resource state change triggers the function), OCI API Gateway (external HTTP requests routed through a gateway to a function), and OCI Streaming (messages in a stream trigger function processing). The exam tests which invocation method is appropriate for which described use case.

OCI API Gateway

What API Gateway provides: OCI API Gateway is a managed API management service that allows publishing, securing, and monitoring APIs exposed to internal or external clients. The exam tests API Gateway as the component between external clients and backend services (Oracle Functions, OCI Compute, or any HTTP endpoint).

API Gateway deployment and routes: A deployment defines the API Gateway’s endpoint and routing rules. Routes map incoming request paths and methods (GET /orders, POST /customers) to backend services. The exam tests route configuration: selecting the backend type (HTTP Backend, Oracle Functions, or Stock Response), configuring path parameters, and setting request/response transformation policies.

Rate limiting and authentication in API Gateway: API Gateway can enforce rate limiting (restricting how many requests a client can make per second) and authentication (validating JWT tokens, API keys, or OCI IAM-signed requests). The exam tests how rate limiting prevents API abuse and which authentication backend is appropriate for different scenarios (JWT for standard OAuth/OIDC flows, OCI IAM for OCI-native clients).

OCI Events

Event rules and automation: OCI Events captures state changes across OCI services (a compute instance is created, an Object Storage object is uploaded, a database is backed up) and routes them to action targets. The exam tests event rule configuration: selecting event types (the actions that trigger the rule), filters (narrowing to specific resources or conditions), and action types (invoking a Function, sending to OCI Notifications, writing to OCI Streaming, or writing to OCI Queue).

Event-driven architecture patterns: The exam tests common event-driven patterns: trigger a function when a new file arrives in Object Storage (object created event → Function action to process the file), trigger notifications when a compute instance fails a health check, cascade workflow stages through events (Stage 1 completion writes an event that triggers Stage 2’s function).

OCI Streaming

OCI Streaming as a message hub: OCI Streaming is a managed Apache Kafka-compatible stream processing service. The exam tests Streaming concepts: streams (the equivalent of Kafka topics), partitions (parallel lanes within a stream that enable parallel consumption), consumer groups (multiple consumers sharing the workload of a stream), and retention period (how long messages are retained before deletion).

Producer and consumer patterns: Producers write messages to a stream; consumers read messages from a stream. A consumer maintains its offset (position in the stream). If a consumer fails and restarts, it can resume from its last committed offset without reprocessing messages or missing messages. The exam tests offset management and why it matters for at-least-once versus exactly-once delivery guarantees.

OCI Queue: A simpler point-to-point messaging service for use cases not requiring stream processing. OCI Queue provides FIFO delivery with dead-letter queue support for handling failed messages. The exam tests when Queue is appropriate (task queuing, job dispatch, simple producer-consumer patterns) versus when Streaming is appropriate (event replay, multiple independent consumers, high-throughput event processing).

Domain 4: Testing and Securing Cloud Native Applications (~15%)

Application Security

OCI Vault for secret management: OCI Vault stores secrets (API keys, passwords, database connection strings, TLS certificates) in a managed, secure repository. Applications retrieve secrets from Vault at runtime using the OCI SDK rather than storing them in code or configuration files. The exam tests the Vault secret lifecycle: creating a secret, rotating a secret (creating a new version while old versions remain accessible for backward compatibility), and how applications authenticate to Vault (using IAM instance principal – the compute instance’s identity, without requiring hardcoded credentials).

OCI Container Registry image scanning: OCIR can scan container images for known vulnerabilities (CVEs) from a maintained vulnerability database. The exam tests how to enable image scanning on a repository, what the scan report contains (severity level, CVE identifier, affected package and version, recommended remediation), and how vulnerability scanning integrates into a CI/CD pipeline (blocking deployment when high-severity vulnerabilities are detected).

Identity and Access Management for applications: Applications running on OCI compute instances or containers should authenticate to OCI services using Instance Principals (for compute) or Resource Principals (for functions) rather than using hardcoded credentials. An Instance Principal is the IAM identity of the compute instance itself – IAM policies grant the instance permissions directly. The exam tests Instance Principal vs. Resource Principal (functions use Resource Principals) and why this is preferable to storing API keys in the application.

Testing Strategies for Cloud Native Applications

Unit testing in microservices: Each microservice should be independently unit-testable in isolation from its dependencies. The exam tests how mock objects substitute for external dependencies (databases, external APIs) during unit tests, enabling fast, isolated testing without running the full application stack.

Integration testing: Testing that multiple microservices work correctly together. Integration tests run against a deployed environment (staging or testing environment) with real or emulated external dependencies. The exam tests that integration tests catch interface contract violations between services that unit tests cannot detect.

Chaos engineering: Intentionally injecting failures (terminating pods, introducing network latency, simulating service unavailability) into a running system to verify that resilience mechanisms work as expected. The exam tests chaos engineering as a validation technique for distributed system resilience, not a performance test.

Domain 5: Monitoring and Troubleshooting Cloud Native Applications (~10%)

OCI Monitoring for applications: Application metrics can be published to OCI Monitoring using the Custom Metrics API. The exam tests how to configure OCI Monitoring alarms that trigger when application-level metrics breach thresholds (request error rate above 5%, response latency above 500ms) and how these alarms integrate with OCI Notifications for alerting.

OCI Logging for containerized applications: Logs from OKE pods can be collected and sent to OCI Logging through the unified monitoring agent installed on node pool instances. The exam tests how to configure the logging agent to collect pod logs from standard output, send them to OCI Logging, and enable log search.

Distributed tracing with APM: In a microservices architecture, a single user request may traverse 5-10 services. When a request is slow or fails, identifying which service is responsible requires distributed tracing. OCI Application Performance Monitoring (APM) collects trace data across all participating services – each service adds a trace context header to outgoing requests, and APM builds the complete request journey. The exam tests how APM’s trace view shows which service contributed how much latency to a slow request.

5 Study Tips for Oracle 1Z0-1084-26

• Tip 1: Allocate two-thirds of your preparation time to Domains 2 and 3 (Containerization and Serverless), because they together account for two-thirds of the exam. If you must deprioritize, Cloud Native Fundamentals (9%) can be studied last.
• Tip 2: Study OKE at the OCI-specific level: VCN-Native Pod Networking vs. Flannel, node pool configuration, OCI Load Balancer integration with Kubernetes Services, and the annotation syntax for configuring OCI-specific load balancer behaviors.
• Tip 3: Study Oracle Functions at the Fn Project architecture level: understand that Oracle Functions is built on Fn Project, how function configuration (memory, timeout) affects execution, and the cold start problem with its mitigation (provisioned concurrency).
• Tip 4: Study OCI API Gateway route configuration and the authentication mechanisms it supports – this is where the exam tests the OCI-specific implementation details that AWS API Gateway familiarity does not cover.
• Tip 5: Practice with Cert Empire’s 1Z0-1084-26 exam questions built at OCI-specific implementation depth – OKE, OCIR, Oracle Functions, and OCI API Gateway configuration scenarios rather than generic cloud-native conceptual questions.

Best Study Resources

• Cert Empire 1Z0-1084-26 exam questions PDF and practice simulator (2026 edition).
• Oracle MyLearn: Oracle Cloud Infrastructure Developer Professional learning path and practice environment.
• Oracle University: OCI Developer Professional course (education.oracle.com).
• OCI Free Tier: Hands-on lab environment for OKE, Oracle Functions, and API Gateway – hands-on configuration is the most effective preparation.
• PassITExams 1Z0-1084-26 study guide with confirmed domain weights.

Career Opportunities After 1Z0-1084-26

• Cloud-Native Application Developer (OCI)
• OCI Solutions Architect
• DevOps Engineer (Oracle Cloud)
• Kubernetes Platform Engineer (OKE)
• Serverless Architect (Oracle Functions)

OCI Developer Professional-certified engineers earn approximately $149,000/year in the US according to ZipRecruiter data, reflecting strong market demand for Kubernetes, serverless, and event-driven architecture skills across cloud platforms. The OCI-specific certification adds Oracle Cloud depth to skills that are broadly applicable.

Why Candidates Choose Cert Empire for Oracle 1Z0-1084-26 Preparation

✔ Domain-weight-aligned question bank. Our 1Z0-1084-26 question bank allocates approximately 33% each to Containerization and Serverless – matching the confirmed two-thirds weighting of these domains.

✔ OCI-specific OKE configuration questions. We test VCN-Native Pod Networking vs. Flannel selection, node pool configuration, and OCI Load Balancer integration with Kubernetes Services at OCI-specific implementation detail.

✔ Oracle Functions Fn Project architecture questions. Our questions test cold starts, function configuration parameters, invocation methods (Events, API Gateway, direct), and the Fn Project open-source platform that underlies Oracle Functions.

✔ API Gateway authentication and rate limiting questions. We test JWT vs. OCI IAM authentication selection, route configuration, and rate limiting policy scenarios.

✔ OCI Vault and Instance Principal security questions. Our questions test why Instance Principal authentication is required over API key hardcoding and how secret rotation works in OCI Vault.

✔ Backed by a full money-back guarantee. If our exam questions do not help you pass, we refund your purchase.

FAQ’s

What is Oracle 1Z0-1084-26?

1Z0-1084-26 is the Oracle Cloud Infrastructure 2026 Developer Professional exam. It validates the ability to design, build, and deploy cloud-native applications on OCI using containerization (Docker, OKE), serverless (Oracle Functions, OCI API Gateway), event-driven architectures, and application security and monitoring.

What are the five domains and their weights?

Cloud Native Applications and Containerization (~33%), Leveraging Serverless Technologies (~33%), Testing and Securing Cloud Native Applications (~15%), Monitoring and Troubleshooting (~10%), and Cloud Native Fundamentals (~9%).

What is OCI Container Engine for Kubernetes (OKE)?

OKE is Oracle’s managed Kubernetes service where Oracle manages the Kubernetes control plane and the customer manages worker node pools. OKE supports VCN-Native Pod Networking (pods receive VCN IP addresses) and integrates with OCI Load Balancers through Kubernetes Service annotations.

What is Oracle Functions built on?

Oracle Functions is built on the open-source Fn Project serverless platform. The Fn Project defines the function execution model, application grouping, and FDK (Function Development Kit) libraries. Understanding Fn Project architecture is relevant to understanding Oracle Functions behavior.

Is prior Kubernetes or serverless experience required?

No formal prerequisites exist, but the exam tests OCI-specific implementation detail. Candidates with Kubernetes and serverless experience on other platforms will have a conceptual foundation – they still need to study OCI-specific behaviors (OKE networking modes, Oracle Functions cold starts, OCIR authentication) that differ from other platforms.

Related Certifications Worth Exploring

Oracle 1Z0-1084-26 certified developers expanding their OCI Professional credential portfolio will find our Oracle Cloud Infrastructure 2026 Cloud Ops Professional (1Z0-1067-26) exam questions page covers enterprise OCI operations, monitoring, logging, automation, reliability, and infrastructure management skills that complement cloud-native application development in production environments. For those extending their development expertise into automated application delivery, our Oracle Cloud Infrastructure DevOps Professional (1Z0-1109-25) exam questions page covers CI/CD pipelines, OCI DevOps services, Kubernetes deployments, automation, and cloud delivery workflows that build naturally on OCI developer skills.