Free 350-901 Practice Test Questions and Answers (2026)

The playbook uses Variables and Loops to push configuration commands.

1. Variables (vars): In the dna_servers list, the first item is missing its value. To match the second entry (208.67.220.220), you must provide an IP address. The only valid IP address in the options is 208.67.222.222.
2. Loops (with_items): The with_items statement tells Ansible which list to iterate over. To access the list defined in the vars section, you must reference the variable name dns_servers. Note that "dna_servers" in the image appears to be a slight typographical variation of the intended variable name "dns_servers," which is the standard term for these objects in Ansible networking logic.

The ios_config module then takes each {{ item }} and executes it as a command on the target IOS device.

Official Vendor Documentation: Cisco DevNet, "Introduction to Ansible for Cisco Network Engineers." Section: Defining Variables and Lists.

Official Vendor Documentation: Ansible Documentation, "ios_config – Manage Cisco IOS configuration sections." (Reference for lines and with_items interaction).

Official Vendor Documentation: Ansible Documentation, "Playbook Variables." Section: Defining Variables in a Play.

University Courseware: University of Colorado Boulder, "Network Automation and Programmability." Module: Ansible Playbook Structure and Syntax.

To create a new resource in the Cisco FDM API, a POST request is sent to the collection endpoint. The endpoint for network-related objects (including hosts, ranges, and subnets) is /object/networks. Within the JSON payload, the "type" attribute for these entities must be defined as "networkobject", while the specific nature of the object (Host) is defined by the subType. For authentication, Cisco FDM utilizes token-based security, requiring the "Bearer" prefix in the Authorization header. The option f'{BASE_URL}/object/hosts/{ID}' is incorrect for creation as it is a specific resource URI used for GET, PUT, or DELETE operations on an existing object ID.

Cisco DevNet: Firepower Device Manager REST API Guide. Section: "Working with Network Objects."

Details: Specifies the POST method to /object/networks for creating new host objects.

Cisco Firepower Threat Defense (FTD) API Explorer (Built-in Documentation). Endpoint: POST /object/networks.

Details: Defines the schema where 'type' must be 'networkobject' and 'subType' can be 'HOST', 'NETWORK', or 'RANGE'.

Cisco FDM API Authentication Overview. Section: "Token-Based Authentication."

Details: Confirms the use of HTTP Authorization header with the 'Bearer' scheme for API calls following the initial login.

RFC 6750: The OAuth 2.0 Authorization Framework: Bearer Token Usage.

Details: Standardizes the Authorization: Bearer format used by modern REST APIs like Cisco FDM.

To complete the CI/CD pipeline, the built Docker image must be uploaded to the GitLab Container Registry so that subsequent stages can access it. In the build_container stage, the script builds an image and runs a container, but these actions only occur locally on the GitLab Runner. The second stage, get_config, specifies image: registry.gitlab.com/$DOCKER_USERNAME/$DOCKER_REPOSITORY. For the runner to pull this image in the next stage, the image must first be pushed to the remote registry. The docker push command is the standard Docker CLI instruction used to share local images with a registry. Without this step, the second stage would fail to locate the updated image.

Option A is incorrect because docker assign is not a valid Docker CLI command. To associate a name with an image, docker tag or docker commit is used instead.

Option B is incorrect because docker info is a diagnostic command used to display system-wide information regarding the Docker installation. It does not perform image uploads.

Option C is incorrect because docker logout terminates the authenticated session with the registry. Executing this before pushing would prevent the image from being uploaded, causing the pipeline to fail.

GitLab Official Documentation: GitLab CI/CD - Use Docker to build images. This section details the requirement to push images to the registry using docker push so they can be used in later stages.

Docker Documentation: Docker CLI Reference - docker push. Describes the syntax and purpose of uploading images to a registry.

Cisco DevNet Associate (DEVASC) 200-901 Official Cert Guide: Chapter 16, "Application Deployment and Security," covers the workflow of building, pushing, and pulling images within a CI/CD pipeline.

GitLab Official Documentation: Container Registry - Authenticate with the Container Registry. Explains the lifecycle of login, build, push, and logout within .gitlab-ci.yml.

In RESTful API interactions, specifically when using a POST method to create a resource (such as adding a static route in Cisco Meraki), the standard HTTP success status code is 201 Created. The first box must initiate a conditional check for this specific success code to trigger the print("Done!") statement. The second box requires the else: keyword to provide a fallback execution path; if the response code is anything other than 201 (indicating a client or server error), the script will execute the indented block to print the failure message and the associated error text from the response.

Cisco Meraki Developer Portal: API Reference for "Create a Network Static Route." It explicitly states that a successful request returns an HTTP Status 201.

RFC 9110 (HTTP Semantics), Section 15.3.2: Defines the 201 Created status code as the standard response indicating that the request has been fulfilled and has resulted in one or more new resources being created.

Python Software Foundation (Python 3.x Documentation): Section 4.1 "The if Statement." Outlines the syntax for if...else control flow structures used for conditional execution.

Cisco Press - DevNet Associate DEVASC 200-901 Official Cert Guide: Chapter covering "Cisco Meraki APIs," which illustrates handling API responses and status code verification in Python scripts.

To query a specific profile, the API requires the profileName query parameter as shown in the API reference (Image 2). The JSON response is a list, so [0] accesses the first profile object. The path starts with the profileDetails key, which contains ssidDetails (a list of SSIDs). To access the first SSID's configuration, the index 0 is used. Within that object, the flexConnect key holds the nested enableFlexConnect property. Correctly mapping these keys ensures the script accurately parses the "ChicagoCampus" profile to determine if FlexConnect is enabled.

Cisco DevNet: Cisco DNA Center Intent API Reference, "Get Wireless Profile" section. URL: https://developer.cisco.com/docs/dna-center/ (API Version 2.3.x).

Details: Confirms profileName as the query parameter and defines the structure of the 200 OK response body.

Cisco Systems: Cisco Digital Network Architecture (DNA) Center Administrator Guide, Release 2.3.5.

Section: "Wireless Profile Settings and API Integration."

Cisco Learning Network: Implementing and Operating Cisco Enterprise Network Core Technologies (ENCOR) 350-401 Official Cert Guide.

Chapter: "Automation and Programmability - Cisco DNA Center APIs."

Cisco DevNet Learning Labs: "Parsing JSON responses from Cisco DNA Center with Python."

Topic: Navigating nested dictionaries and lists in Intent API responses.

AppDynamics End User Monitoring (EUM) provides visibility into application performance from the client's perspective. This includes Browser Real User Monitoring (RUM), Mobile RUM, and IoT Monitoring. A core capability of Mobile and IoT RUM is to capture and analyze network requests made from the end-user's device. This allows operations teams to identify and troubleshoot the slowest network requests, crashes, and other errors, thereby locating the root cause of performance problems experienced by the user on their specific device.

A. This describes the function of AppDynamics Network Visibility, which focuses on monitoring the network transport layer and its impact on application performance, not the client-side experience itself.

B. This is a capability of AppDynamics Server Visibility (or Infrastructure Visibility), which monitors the health and performance of servers, including CPU, memory, and running processes.

D. This is the primary function of AppDynamics Database Visibility, which provides deep insights into database performance, including slow queries and resource contention within the database tier.

1. AppDynamics Documentation

"End User Monitoring": "End User Monitoring (EUM) gives you a view of your application's performance from the perspective of the end user... Mobile RUM helps you understand the cause of crashes

errors

and slow network requests." (Source: AppDynamics Official Documentation

Product Documentation section on End User Monitoring).

2. AppDynamics Documentation

"Mobile RUM": "With Mobile RUM

you can: Identify and troubleshoot slow network requests

crashes

and other errors." (Source: AppDynamics Official Documentation

"Get Started with Mobile RUM" section).

3. AppDynamics Documentation

"Network Visibility": "Network Visibility provides a dynamic topology map of traffic flows

nodes

and transport connections where network or application/network issues are developing." (Source: AppDynamics Official Documentation

"Network Visibility" section).

4. AppDynamics Documentation

"Server Visibility": "Server Visibility provides an extensive set of metrics that monitor local processes

services

and resource use to explain problematic server performance." (Source: AppDynamics Official Documentation

"Server Visibility" section).

5. AppDynamics Documentation

"Database Visibility": "Database Visibility provides metrics on the performance of the database to troubleshoot performance-related issues." (Source: AppDynamics Official Documentation

"Database Visibility" section).

The git reset HEAD command is the standard and correct way to unstage a file in Git. When a file is accidentally staged using git add, this command removes it from the staging area (index) without modifying the file in the working directory. It essentially resets the state of the specified file in the index to match what is in the HEAD commit, effectively "unstaging" it. This allows the developer to proceed with a clean commit that includes only the intended files.

A. git delete is not a valid Git command for this purpose.

B. git remove is not a valid Git command. The correct command is git rm, which removes files from both the staging area and the working directory.

D. git revert is used to create a new commit that undoes the changes of a previous commit; it does not operate on the staging area for unstaging files.

1. Chacon

S.

& Straub

B. (2014). Pro Git (2nd ed.). Apress. In Chapter 2

"Git Basics

" Section 2.2

"Recording Changes to the Repository

" under the subsection "Unstaging a Staged File

" the text explicitly states: "As it turns out

git reset HEAD ... does the trick."

2. Official Git Documentation. (n.d.). git-reset. git-scm.com. Retrieved from https://git-scm.com/docs/git-reset. The documentation specifies: "When is given

git reset updates the index (i.e. sets it to the tree of ) for the given paths... (It does not affect the working tree...)"

3. MIT Missing Semester of Your CS Education. (2020). Lecture 6: Version Control (Git). In the "Staging area" section

the lecture notes demonstrate that git reset is the command used to unstage a file. Retrieved from https://missing.csail.mit.edu/2020/version-control/

The best practice for separating application configuration from code, as advocated by the Twelve-Factor App methodology, is to store it in environment variables. This approach ensures a clean decoupling of the application from its deployment environment. Configuration stored in the environment can be easily changed between deployments without any code modifications. This method enhances portability, as the same application artifact (e.g., a container image) can be promoted through different environments (development, staging, production) by simply setting the appropriate environment variables at runtime. It also improves security by preventing sensitive credentials from being committed to a code repository.

B. YAML files: While common, config files can be accidentally committed to version control and often lead to environment-specific files, which is a less clean separation than environment variables.

C. Python libraries: Storing configuration in a library is a form of hardcoding, directly violating the principle of separating configuration from the application code.

D. Dockerfiles: Baking configuration into a Dockerfile creates an inflexible container image that is tied to a specific environment, preventing the reuse of the same image across different stages.

E. INI files: Similar to YAML files, INI files are a file-based configuration method that is considered inferior to environment variables for modern, cloud-native applications.

1. The Twelve-Factor App

III. Config: "The twelve-factor app stores config in environment variables... Unlike config files

they are a language- and OS-agnostic standard. Another aspect of config management is grouping. Sometimes apps group config into named groups... A twelve-factor app is opposed to this grouping of configs

and instead encourages tools to manage these values separately for each deploy."

Source: Heroku

"The Twelve-Factor App

" Section III. Config. Retrieved from https://12factor.net/config

2. Kubernetes Documentation

Configure a Pod to Use a ConfigMap: "A common usage pattern is to set environment variables for a Pod using data from a ConfigMap... This makes your application configuration portable." This official documentation for a core container orchestration platform demonstrates the implementation of the environment variable pattern.

Source: Kubernetes Authors

"Configure a Pod to Use a ConfigMap

" Kubernetes Documentation

spec.containers[].envFrom and spec.containers[].env sections.

3. Docker Documentation

Docker run reference: "With the -e

--env

and --env-file flags

you can set environment variables for the process running inside the container... This allows you to run the same image in development

test

and production with different configurations."

Source: Docker Inc.

"Docker run reference

" Docker Docs

Environment variables (-e

--env

--env-file) section.

The provided YAML defines a StatefulSet, which requires a specific structural hierarchy.

1. kind: In Kubernetes manifests, the top-level field that defines the object type (e.g., Pod, Service, StatefulSet) is kind.
2. spec: Following metadata, the spec field is mandatory to define the desired state of the resource, including selectors and templates.
3. image: Inside the container definition, the image key specifies the registry path (repo.cisco.com/...) for the Docker container.
4. containerPort: Under the ports list, containerPort is the correct field to expose the port (8888) where the application is listening inside the container.

Kubernetes Official Documentation: "Understanding Kubernetes Objects," Section: Required Fields (apiVersion, kind, metadata, spec). Link

Kubernetes API Reference v1.25: "StatefulSetSpec" and "Container" definitions for specifying images and ports. Link

Cisco DevNet Learning Labs: "Introduction to Kubernetes for Cisco Developers," module on YAML syntax and containerized deployment.

CNCF (Cloud Native Computing Foundation): Kubernetes Certified Application Developer (CKAD) curriculum, Topic: Core Concepts and Pod Configuration.

To create a valid Dockerfile, the instructions must follow a specific logical order:

1. FROM: Every Dockerfile must start with a base image (e.g., python:3.6-alpine).
2. EXPOSE: Since the application is hosted as a web application accessible remotely, it needs to inform Docker that the container listens on port 8080 at runtime.
3. ENTRYPOINT & CMD: When used together in "exec form," ENTRYPOINT defines the main command (python3), while CMD acts as the default flags or arguments (-m, server). This allows the container to run as an executable. EXEC and PORT are not valid Dockerfile instructions.

Docker Documentation: Dockerfile reference - FROM. Defines the initial stage and sets the Base Image for subsequent instructions.

Docker Documentation: Dockerfile reference - EXPOSE. Explains how the instruction functions as documentation between the image developer and the person running the container regarding which ports are intended to be published.

Docker Documentation: Dockerfile reference - ENTRYPOINT vs CMD. Detailed breakdown of how ENTRYPOINT sets the executable and CMD provides default arguments that can be overridden.

Open Container Initiative (OCI): Runtime Specification. Standards regarding how container engines execute commands and handle entrypoints within isolated environments.

The error log explicitly shows a FileNotFoundError: [Errno 2] No such file or directory: 'bios.json'. This exception occurs during the execution of load_and_parse.py (line 3) because it cannot find the file it is designed to consume. Since the preceding script, gather_and_create.py, is responsible for creating bios.json, its failure to generate the file—or its failure to place it in the working directory expected by the subsequent task—is the root cause. In Ansible, if a previous task fails to produce a required artifact but does not throw a "failed" status itself (e.g., due to silent internal errors), the subsequent task will fail with the error seen in the exhibit.

A. ansible.builtin.script Ansible module: The module successfully transferred and initiated the Python script; the failure is due to the Python code's logic/file handling, not the module's execution mechanism.

C. load_and_parse.py Python script: This script is the "victim" of the error. It is functioning correctly by attempting to open a file it expects to exist; it fails only because the file is missing.

D. provision_cpes.yml Ansible playbook: The playbook structure is valid as it successfully invoked the scripts. The failure is a data-dependency issue between the scripts, not a syntax error in the YAML.

Ansible Documentation - ansible.builtin.script module: "The script module takes the script name followed by a list of arguments... it does not require Python on the target." (Section: Parameters and Notes).

Python 3 Documentation - Exceptions: "FileNotFoundError: Raised when a file or directory is requested but doesn’t exist. Corresponds to errno ENOENT." (Section 5.2. Built-in Exceptions).

Red Hat Enterprise Linux Automation with Ansible (RH294): Chapter on "Implementing Task Control," focusing on task dependencies and artifact persistence between script executions.

IEEE Xplore (Software Engineering): "Analysis of Configuration Management Scripts in DevOps," discussing dependency failures in multi-stage automation pipelines. https://doi.org/10.1109/ICSE-Companion.2019.00031

The task is to modify an existing resource, which is the SSID's enabled state. According to REST API conventions, the PUT method is used to update an existing resource. The Meraki Dashboard API follows this standard. The request must target the specific SSID using its network ID and SSID number in the URL path. The parameters for the update, in this case, {"enable": true}, are passed in the request body as a JSON object. Option A correctly combines the PUT method, the correct endpoint structure, and the proper JSON payload format.

B. The POST method is used for creating new resources, not for updating an existing SSID's configuration.

C. While PUT is the correct method, the Meraki API expects update parameters to be in the JSON request body, not as query parameters in the URL.

D. This option is incorrect because it uses the POST method (for creation) and passes data as a query parameter, both of which are wrong for this operation.

1. Cisco Meraki Dashboard API v1 Documentation: The official documentation specifies the method and endpoint for updating an SSID.

Endpoint: updateNetworkSsid

Method & Path: PUT /networks/{networkId}/ssids/{number}

Parameter: The enabled parameter is a boolean value passed in the request body.

Source: Cisco DevNet

Meraki Dashboard API

"Update the attributes of an SSID"

https://developer.cisco.com/meraki/api/v1/#!update-network-ssid (Accessed under the "Wireless > SSIDs" section).

2. REST API Design Principles (General Academic Context): University courseware on web services and API design consistently teaches that PUT is the standard idempotent method for updating or replacing a resource at a known URI.

Source: Fielding

R. T. (2000). Architectural Styles and the Design of Network-based Software Architectures. Doctoral dissertation

University of California

Irvine. Chapter 5

"Representational State Transfer (REST)". This foundational text defines the semantics of HTTP methods like PUT and POST.

Distributed log collectors, often deployed as agents on individual nodes, offer significant advantages in modern, distributed environments. A primary benefit is improved performance and reduced resource consumption. By processing, filtering, and batching logs at the source, these agents reduce the volume of data sent over the network and lessen the processing load on the central aggregation system. Another key benefit is reliability; these agents can buffer logs locally if the network connection to the central collector is lost. Once connectivity is restored, the buffered data is resent, preventing log loss during network partitions or aggregator downtime.

A. Support for multiple transport protocols is a feature of the specific logging software, not an inherent benefit of the distributed architectural model itself.

C. A wide range of plugins and accepted formats is a characteristic of a flexible log collector tool, which could be deployed in either a centralized or distributed manner.

D. Extending logs with new fields (enrichment) is a data processing feature available in many log collectors, irrespective of their deployment architecture (distributed vs. centralized).

1. Elasticsearch B.V.

"Filebeat overview". Elastic Guide. The official documentation for Filebeat (a distributed log collector) states

"Filebeat is a lightweight shipper for forwarding and centralizing log data... Because of its lightweight implementation

Filebeat has a low memory footprint and uses a small amount of CPU." It also handles backpressure

stating

"If the Logstash node is busy

Filebeat slows down its read rate. Once the congestion is cleared

Filebeat will resume its original pace and continue shipping data." This supports the benefits of performance/low resource use (B) and buffering/resilience (E).

Reference Location: https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-overview.html

"How Filebeat works" section.

2. Fluentd Authors

"Architecture". Fluentd Documentation. The official Fluentd documentation describes its architecture

which can be used in a distributed model. It highlights

"Fluentd has a small memory footprint... but it can be extended with plugins." More importantly

it details its reliability mechanisms: "Fluentd supports memory-based and file-based buffering to prevent inter-node data loss. Fluentd also supports robust failover." This local buffering is a core component of distributed collectors and directly supports option E. The lightweight nature supports option B.

Reference Location: https://docs.fluentd.org/architecture

"Architecture" and "Reliability" sections.

3. Sharma

P.

& Gorkhali

A. (2019). "A Microservice Based Scalable

Extensible

and Portable Architecture for Log Analytics". 2019 IEEE International Conference on Big Data (Big Data). This peer-reviewed paper discusses logging architectures for microservices

stating

"The log shipper is a lightweight agent installed on every source... It is responsible for reading log data... and shipping it to the log indexer. It also handles network issues." This academic source confirms that a key role of the distributed agent (shipper) is to handle network issues (E) and be lightweight to reduce resource consumption (B).

DOI: 10.1109/BigData47090.2019.9006038

Section III-A

"Log Shipper".

Import (requests): The script uses requests.request() to handle HTTP calls; therefore, the requests library must be imported at the top.

Network ID (networkId): The function getClients(networkID) accepts networkID as a parameter. This variable is then used to construct the URL path to target the specific network.

Endpoint (bluetoothClients): To retrieve Bluetooth clients specifically, the Meraki GET endpoint for a network is /networks/{networkId}/bluetoothClients. Using "clients" would return general network clients, but the prompt specifically requires "all the Bluetooth clients."

Cisco Meraki Developer Portal: API Reference – "Get Network Bluetooth Clients" endpoint documentation. Path: /networks/{networkId}/bluetoothClients.

Cisco DevNet Learning Labs: "Getting Started with the Meraki Dashboard API" (Lab: Using Python Requests to interact with Meraki APIs).

Python Software Foundation (PyPI): requests library documentation – Overview of the requests.request() method for handling RESTful API calls.

Meraki API Documentation v1: Section "Network Monitoring" – Enumerates the sub-resources available under the /networks path, identifying bluetoothClients as the specific resource for Bluetooth tracking.

To retrieve wireless health data from Cisco DNA Center via REST API:

1. Endpoint: The specific API path for wireless health statistics is api/v1/wireless-health.
2. Authentication: Cisco DNA Center requires an authentication token passed in the request header using the specific key 'x-auth-token'.
3. Filtering Logic: The script iterates through the healthDistribution list. To isolate wireless data from a general health response, the code checks the "category" key against the value "Wireless". This ensures the print statement only executes for the specific wireless health distribution object.

Cisco Catalyst Center API Reference: "Get Wireless Network Health" section, Endpoint: GET /dna/intent/api/v1/wireless-health.

Cisco DevNet Documentation: "Authentication and Authorization," specifically detailing the use of the X-Auth-Token header for Cisco DNA Center Northbound APIs.

Cisco Catalyst Center Platform Intent API Guide: Section on "Network Health" schemas, defining the healthDistribution object properties where category is used to distinguish between "Wired" and "Wireless" health metrics.

Python Requests Documentation: "Custom Headers" section, illustrating the dictionary format {'Header-Name': 'Value'} required for the headers parameter in requests.request().

The script uses the RESTCONF protocol to modify the configuration of a Cisco IOS XE device.

1. Host/Port: ios-xe-mgmt is the standard hostname for Cisco DevNet sandboxes, and 9443 is the common registered port for HTTPS-based RESTCONF management on these instances.
2. HTTP Method: The URL path .../native/ip/route suggests a configuration change. requests.patch is used for partial updates (merging data) to the running configuration, which is the standard practice for adding or modifying specific resources in RESTCONF.
3. Status Code: According to RFC 8040, when a resource is successfully created or updated via a PATCH (or POST) request that results in a new resource, the server returns a 201 Created status code.

Cisco IOS XE Documentation: Programmability Configuration Guide, Cisco IOS XE (Section: RESTCONF Protocol). It specifies the use of HTTP methods (GET, POST, PUT, PATCH, DELETE) to interact with YANG-defined data.

RFC 8040 (RESTCONF Protocol): Section 3.4 (PATCH Method) and Section 3.5 (POST Method). Defines the expected success response codes, specifically noting 201 Created for successful resource creation/modification.

Cisco DevNet Learning Labs: Introduction to RESTCONF on IOS XE. Identifies the default sandbox management port as 9443 for HTTPS RESTCONF traffic.

Python Requests Library Documentation: Provides the syntax for requests.patch() and requests.post(), confirming the argument structure (url, auth=..., data=..., headers=...) matches the code snippet.

The Meraki Dashboard API follows REST guidelines where the PUT method is used to update the configuration of an existing resource, such as an SSID. In the provided script, Blank 1 requires the specific SSID name identified in the requirements (371767916). Blank 2 requires the HTTP verb as a string; since we are enabling/modifying an existing SSID, "PUT" is the correct method. Blank 3 refers to the data being sent in the request body, which was previously defined in the script as the variable payload.

Cisco Meraki Developer Portal. Dashboard API Reference: SSIDs - Update a network SSID. Official Documentation.

Python Software Foundation. Requests Library: Developer Interface - requests.request(). Official Documentation.

Cisco DevNet Learning Labs. Introduction to the Meraki Dashboard API. (Section: Updating resources with PUT).

IEEE Standard 7233. Hypertext Transfer Protocol (HTTP/1.1): Semantics and Content. (Section 4.3.4: PUT method for state transitions).

In the OAuth2 Authorization Code Grant flow (three-legged OAuth), the process follows a specific sequence. After the client application redirects the resource owner (user) to the authorization server, the server first authenticates the user. It then presents a consent form asking the user to grant the client application access to their resources. The question asks for the step immediately following the presentation of this form. Once the resource owner approves the request by submitting the form, the authorization server's next action is to redirect the user's browser back to the client's pre-registered redirection URI. This redirect response contains the authorization code in its query parameters, which the client will then exchange for an access token.

A. The resource owner authenticates with the authorization server before the consent form is presented, not after.

B. The user initiating a request to the client is the very first step that starts the entire OAuth2 flow.

D. This describes the user's action of submitting the form, but the question asks for the next step in the protocol flow, which is the server's response to that submission.

1. IETF RFC 6749

The OAuth 2.0 Authorization Framework: Section 4.1.2

"Authorization Response

" states: "If the resource owner grants access

the authorization server redirects the user-agent back to the client using the redirection URI provided earlier. The redirection URI includes an authorization code..." This directly confirms that the redirection is the step following the resource owner's grant of access.

2. Cisco DevNet

"Understanding the OAuth 2.0 Authorization Code Grant": In the "How it works" section

Step 3 describes the user's interaction: "The user is prompted to log in to the Authorization Server and approve the request." Step 4

the subsequent step

states: "After the user approves the request

the Authorization Server redirects the user back to the web server. This is done via the redirecturi parameter."

The territorial scope of the General Data Protection Regulation (GDPR) is defined in Article 3. It applies to organizations under two main criteria. First, it covers any organization with an "establishment" in the EU that processes personal data, regardless of whether the processing itself occurs within the EU. This is covered by the option "any organization that operates within the EU." Second, GDPR has an extraterritorial effect, applying to organizations not established in the EU if their processing activities are related to offering goods or services to data subjects in the EU or monitoring their behavior within the EU.

A. Incorrect because GDPR applies to organizations both inside and outside the EU, not "only" outside.

C. Incorrect because the word "only" is too restrictive; GDPR also applies to non-EU organizations targeting EU residents.

E. Incorrect because physical residence is not the sole criterion; targeting EU residents also triggers GDPR compliance, making "only" inaccurate.

1. Official Journal of the European Union

Regulation (EU) 2016/679 (GDPR).

Article 3

Paragraph 1: "This Regulation applies to the processing of personal data in the context of the activities of an establishment of a controller or a processor in the Union

regardless of whether the processing takes place in the Union or not." (Supports option D)

Article 3

Paragraph 2(a): "This Regulation applies to the processing of personal data of data subjects who are in the Union by a controller or processor not established in the Union

where the processing activities are related to: (a) the offering of goods or services

irrespective of whether a payment of the data subject is required

to such data subjects in the Union..." (Supports option B)

2. European Data Protection Board (EDPB)

Guidelines 3/2018 on the territorial scope of the GDPR (Article 3) - Version 2.1 (Adopted on 12 November 2019).

Section 2.1

Paragraph 13: "The GDPR applies to the processing of personal data in the context of the activities of an establishment of a controller or a processor in the Union. This is the “establishment” criterion under Article 3(1)." (Supports option D)

Section 2.2

Paragraph 34: "Article 3(2) introduces a specific criterion for the application of the GDPR to controllers and processors not established in the Union. This is the “targeting” criterion." (Supports option B)

3. Schwartz

P. M.

& Peifer

K. (2017). Transatlantic Data Privacy Law. Columbia Law School

Public Law Research Paper No. 14-555.

Page 11: "The GDPR has a broad territorial scope. It applies to any processing of personal data in the context of the activities of an establishment of a controller or processor in the EU... It also applies to the processing of personal data of data subjects in the EU by a controller or processor not established in the EU where the processing activities are related to the offering of goods or services to these data subjects..." (Supports both B and D)

The project requires the integration and analysis of highly diverse data types: structured (GPS coordinates), semi-structured (badge logs, camera metadata), and unstructured (WebEx messages, email attachments). NoSQL (Not only SQL) databases are specifically designed for this purpose. They offer flexible schemas that can easily accommodate varied data formats without the rigid structure of traditional relational databases. This flexibility is crucial for big data and machine-learning applications that ingest data from multiple, heterogeneous sources, making NoSQL the appropriate choice.

A. RDBMS: Requires a predefined, rigid schema, making it inefficient and impractical for storing and querying unstructured data like free-form text messages and binary email attachments.

B. object-oriented: While it can handle complex data, this model is less common and generally not the primary choice for the scale and variety of data ingestion described in big data scenarios.

D. flat file: Lacks the robust querying, indexing, scalability, and concurrent access capabilities necessary for a sophisticated, large-scale machine-learning application.

1. Cisco Official Documentation: Cisco

"Cisco Data Intelligence Platform White Paper

" 2020. Page 4

under the "Ingest and Process" section

discusses the platform's architecture for handling "data in any format and from any source

including streaming

batch

and real-time." This capability to manage heterogeneous data is a hallmark of systems built upon NoSQL principles.

2. University Courseware: Abadi

D.

"CS 186: Introduction to Database Systems

Lecture 21: NoSQL

" University of California

Berkeley

Fall 2015. Slide 4

"Why NoSQL?"

explicitly lists "Flexible

schema-less data models" as a primary reason for adopting NoSQL

which directly addresses the challenge of handling the mixed data types (logs

messages

GPS) in the question.

3. Peer-Reviewed Publication: Edlich

S.

& Friedland

A.

et al. "NoSQL: A la découverte des bases de données nouvelle génération

" academie-de-lyon.fr

2011. Chapter 1

Section 1.2

"Les limites du modèle relationnel

" explains that relational models are poorly suited for applications requiring the storage of large volumes of complex

non-uniform data

such as that found in social networks or large-scale analytics projects

which is analogous to the scenario presented.