I85PREP
⌘ K
Dataiku Developer Certification study materials
Dataiku Developer Certification study resources

Dataiku Developer Certification practice questions

One question at a time. Build your Dataiku Developer Certification understanding.

First 50 of 190 questions. Each one lists the choices, the correct answer, and an explanation. The checker at the top of this page saves progress in this browser when it is available.

Continue in the practice tool above to load more questions, 50 at a time.

Question 1Dataiku code recipes, datasets, environments and extension boundaries

In a Dataiku Python recipe, which sequence of calls reads an input dataset named "customers" into a Pandas DataFrame using the dataiku package?

  1. df = dataiku.Dataset("customers").get_dataframe() Correct answer.
  2. df = dataiku.read_csv("customers")
  3. df = dataiku.Flow().load("customers").to_pandas()
  4. df = dataikuapi.Dataset("customers").read()

Explanation

Inside a Python recipe you obtain a handle with dataiku.Dataset("name") and call get_dataframe() to read the whole dataset into a Pandas DataFrame, regardless of the storage backend. This is the canonical reading pattern documented for Python recipes.

Question 2Dataiku code recipes, datasets, environments and extension boundaries

A Python recipe builds an output DataFrame whose columns differ from the existing output dataset schema. Which method writes the DataFrame AND updates the output dataset's schema to match the DataFrame in one call?

  1. output.write_dataframe(df)
  2. output.write_schema_from_dataframe(df)
  3. output.write_with_schema(df) Correct answer.
  4. output.append_dataframe(df)

Explanation

write_with_schema() writes the DataFrame and replaces the output dataset's schema with the DataFrame's schema on every run. It is the standard way to handle outputs whose columns change, though it should be used with care since downstream Flow steps depend on schema.

Question 3Dataiku code recipes, datasets, environments and extension boundaries

When writing rows individually with dataiku.Dataset(...).get_writer(), why is it strongly recommended to use the Python "with" statement?

  1. It enables multithreaded writing to the dataset
  2. It compresses the output to Parquet by default
  3. It automatically infers the schema from the first row written
  4. It guarantees the writer is closed so all buffered rows are flushed; otherwise data may not be fully written Correct answer.

Explanation

Using the supported writer as a context manager closes it appropriately when control leaves the block, including relevant exception paths. That supports flushing and resource cleanup, but I/O, permission or validation errors can still prevent a complete successful write. Check actual completion and intended output rather than call with an unconditional data-delivery guarantee.

Question 4Dataiku code recipes, datasets, environments and extension boundaries

A dataset is far too large to fit in memory. Which dataiku.Dataset reading approach lets a Python recipe process it in fixed-size blocks?

  1. get_dataframe(sample=True)
  2. iter_dataframes(chunksize=N) Correct answer.
  3. get_dataframe().chunk(N)
  4. read_partitions(N)

Explanation

iter_dataframes returns batches under the specified chunk setting, allowing processing without first loading the entire dataset into one dataframe. Downstream accumulation, joins, library overhead and the actual data can still consume substantial memory. Choose a justified chunk size and verify the supported execution and output behavior.

Question 5Dataiku code recipes, datasets, environments and extension boundaries

By default, dataiku.Dataset("x").get_dataframe() infers column dtypes from the data rather than the dataset's declared schema. Which argument forces it to use the dataset schema's storage types instead?

  1. get_dataframe(use_schema=True)
  2. get_dataframe(coerce=True)
  3. get_dataframe(strict_types=True)
  4. get_dataframe(infer_with_pandas=False) Correct answer.

Explanation

get_dataframe() uses a Pandas read under the hood and by default infers dtypes from data. Passing infer_with_pandas=False makes it use the dataset schema's declared types, which is useful when inference produces unexpected types (e.g., a numeric ID read as int but needed as string).

Question 6Dataiku code recipes, datasets, environments and extension boundaries

What is the primary purpose of a Dataiku code environment?

  1. To provide an isolated set of Python or R packages (and a language version) that recipes, notebooks, and models can use Correct answer.
  2. To store project variables shared across recipes
  3. To define the schema of input and output datasets
  4. To control which users can run a given scenario

Explanation

A code environment supplies relevant language and package dependencies for supported execution. It is not by itself a complete security sandbox or data-access boundary. Actual DSS version, permissions, execution mode, package compatibility and container configuration govern how it can be used.

Question 7Dataiku code recipes, datasets, environments and extension boundaries

You need a Python recipe to run with a specific set of packages different from the instance default. How do you make the recipe use a particular managed code environment?

  1. Add a #env directive at the top of the recipe code
  2. Select the code environment in the recipe's Advanced (code env) settings Correct answer.
  3. Install the packages into the recipe with pip at runtime
  4. Set a project variable named CODE_ENV

Explanation

Each code recipe (and notebook, webapp, or model) has a code environment selection in its advanced settings where you can choose the instance default or a specific named code environment. This binds execution to that environment's packages and language version.

Question 8Dataiku code recipes, datasets, environments and extension boundaries

What is the difference between a Dataiku code notebook and a Python recipe?

  1. Notebooks can read datasets but recipes cannot
  2. A notebook is an interactive scratchpad for exploration that is not part of the Flow, whereas a recipe is a Flow object that transforms inputs into outputs Correct answer.
  3. Recipes run only on the API node, notebooks only on the design node
  4. Notebooks must be written in R, recipes only in Python

Explanation

Code notebooks (Jupyter-based for Python/R) are interactive environments for exploration and prototyping and are not part of the Flow. A code recipe is a persistent Flow component with declared input and output datasets that is run as part of building the Flow. Code is often prototyped in a notebook then deployed as a recipe.

Question 9Dataiku code recipes, datasets, environments and extension boundaries

A Python recipe declares an output dataset whose schema you want to set explicitly before writing rows with a writer. Which method sets the output schema as a list of column definitions?

  1. output.set_columns([...])
  2. output.create_schema([...])
  3. output.define_schema([...])
  4. output.write_schema([{"name": "origin", "type": "string"}, ...]) Correct answer.

Explanation

write_schema() takes a list of column definition dicts (each with name and type) and sets the output dataset's schema. It is typically called before opening a writer with get_writer() to write rows whose structure matches the declared schema.

Question 10Dataiku code recipes, datasets, environments and extension boundaries

Which kinds of code recipes can read a SQL dataset and an HDFS dataset and write to, say, an S3 dataset, abstracting away the storage backends?

  1. Python (and R) recipes, which use the dataiku dataset API to read and write regardless of backend Correct answer.
  2. Only SQL recipes
  3. Only Spark recipes
  4. Only visual recipes; code recipes are backend-locked

Explanation

Python and R recipes use the dataiku dataset API, which abstracts storage so a single recipe can read from SQL and HDFS inputs and write to an S3 output. The recipe code does not need to handle each backend's connection details directly.

Question 11Dataiku code recipes, datasets, environments and extension boundaries

What is the most common, recommended way to share Python code across multiple recipes and notebooks within a single Dataiku project?

  1. Copy and paste the functions into each recipe
  2. Store the code as a project variable and exec() it
  3. Put the code in the project's Libraries (project library / lib/python) and import it Correct answer.
  4. Email the script to collaborators

Explanation

Each project has a Library (the Libraries editor, backed by lib/python) where you place reusable Python modules. Recipes and notebooks can then import those modules directly, which is the standard mechanism for sharing code within a project. Plugins and code samples are other sharing options.

Question 12Dataiku code recipes, datasets, environments and extension boundaries

In a Dataiku Python recipe, how do you correctly obtain the handles for the recipe's declared input and output datasets so the Flow tracks the dependency?

  1. By opening the underlying files directly with open()
  2. By querying the database connection with raw SQL
  3. By instantiating dataiku.Dataset with the names declared in the recipe's Input/Output tab Correct answer.
  4. By reading from a hard-coded local /tmp path

Explanation

You reference inputs and outputs by name using dataiku.Dataset("name"), where the names match those declared on the recipe's Input/Output tab. This is what lets the Flow build the dependency graph and run things in the correct order; bypassing it with direct file access breaks Flow tracking.

Question 13Dataiku code recipes, datasets, environments and extension boundaries

When you update a managed code environment's package list, what must DSS do before the new packages are usable?

  1. Nothing; package changes apply instantly
  2. Rebuild the environment (and, for containerized execution, rebuild the corresponding Docker images) Correct answer.
  3. Restart the entire DSS instance for every package change
  4. Recreate every recipe that uses the environment

Explanation

After editing the package list you click Save and update, which rebuilds the environment by installing the requested packages. If the environment is used for containerized execution, the corresponding Docker images are rebuilt so the containers include the updated packages.

Question 14Dataiku code recipes, datasets, environments and extension boundaries

Which language(s) can be used to write code recipes in Dataiku, beyond Python?

  1. Only Python
  2. Only JavaScript
  3. Only R
  4. R, SQL, PySpark, SparkR, Spark SQL, Hive, Shell, and others in addition to Python Correct answer.

Explanation

Dataiku supports many code recipe types, including Python, R, SQL, PySpark, SparkR, Spark SQL, Hive, Pig, and Shell. The Developer track centers on Python and R but a coder is expected to know the broader set of code recipe options.

Question 15Dataiku code recipes, datasets, environments and extension boundaries

In a managed folder accessed from Python, which dataiku class provides read and write access to arbitrary files (not tabular datasets)?

  1. dataiku.Dataset
  2. dataiku.File
  3. dataiku.Folder Correct answer.
  4. dataiku.Blob

Explanation

dataiku.Folder gives a handle to a managed folder, exposing methods such as get_download_stream, upload_stream, and list_paths to read and write arbitrary files (models, images, JSON, etc.). Managed folders are how coders store non-tabular artifacts in the Flow.

Question 16Dataiku code recipes, datasets, environments and extension boundaries

A coder wants to convert an exploratory Python notebook into a reproducible Flow step. What is the recommended path?

  1. Create a Python recipe (optionally from the notebook) with declared input/output datasets so it becomes part of the Flow Correct answer.
  2. Leave the code in the notebook and schedule the notebook directly in a scenario as the production step
  3. Export the notebook to PDF and re-type it
  4. Wrap the notebook in a webapp

Explanation

Notebooks are for exploration; to make logic reproducible and part of the Flow you create a Python recipe with declared inputs and outputs (Dataiku lets you create a recipe from a notebook). The recipe is then buildable, schedulable, and tracked as a Flow dependency.

Question 17Dataiku code recipes, datasets, environments and extension boundaries

Which Python package is used INSIDE Dataiku (recipes, notebooks) to interact with the current project's datasets, folders, and variables?

  1. dataiku Correct answer.
  2. dataikuapi
  3. dss-client
  4. pandas-dataiku

Explanation

The dataiku package is the internal API used within recipes and notebooks to access the current project's datasets, managed folders, models, and variables (e.g., dataiku.Dataset, dataiku.Folder, dataiku.get_custom_variables). It runs in the context of the project that hosts the code.

Question 18Dataiku code recipes, datasets, environments and extension boundaries

Which package is the client for Dataiku's public REST API, used to administer a DSS instance programmatically from an external script?

  1. dataiku
  2. requests-dss
  3. dataikuapi Correct answer.
  4. dss-admin

Explanation

dataikuapi is the public REST API client. From outside DSS you create a dataikuapi.DSSClient with the instance URL and an API key, then manipulate projects, datasets, recipes, code environments, scenarios, and more. It is distinct from the in-recipe dataiku package.

Question 19Dataiku code recipes, datasets, environments and extension boundaries

Using the public API from an external Python script, which sequence creates a client and obtains a handle to a specific project?

  1. client = dataiku.DSSClient(); project = client.project("KEY")
  2. client = dataikuapi.connect(); project = client.load("PROJECTKEY")
  3. project = dataikuapi.open_project("PROJECTKEY")
  4. client = dataikuapi.DSSClient(host, api_key); project = client.get_project("PROJECTKEY") Correct answer.

Explanation

You instantiate dataikuapi.DSSClient(host, apiKey) and then call get_project("PROJECTKEY") to get a DSSProject handle. From that handle you access datasets, recipes, scenarios, variables, and other project objects via the REST API.

Question 20Dataiku code recipes, datasets, environments and extension boundaries

What is required to authenticate a dataikuapi.DSSClient against a remote DSS instance?

  1. Only the instance URL
  2. The instance base URL and a valid API key (personal or application/global) Correct answer.
  3. A username and password only, never an API key
  4. Nothing; the client connects anonymously

Explanation

DSSClient(host, api_key) needs the instance base URL and an API key. API keys can be personal, application, or global, and their permissions determine what the client can do (e.g., managing code environments requires the appropriate permission on the key).

Question 21Dataiku code recipes, datasets, environments and extension boundaries

From within a recipe, which dataiku function obtains a client for the CURRENT instance's public API without manually supplying a host and API key?

  1. dataiku.get_custom_variables()
  2. dataiku.Project().client()
  3. dataikuapi.DSSClient.local()
  4. dataiku.api_client() Correct answer.

Explanation

Inside DSS, dataiku.api_client() returns a dataikuapi.DSSClient already authenticated for the local instance, so you can call public-API methods (managing projects, scenarios, code envs, etc.) without hard-coding a host or API key. This bridges the in-recipe dataiku package and the public dataikuapi client.

Question 22Dataiku code recipes, datasets, environments and extension boundaries

Using the public API, which DSSProject method retrieves the project's standard and local variables as a dictionary?

  1. project.get_variables() Correct answer.
  2. project.list_variables()
  3. project.read_vars()
  4. project.variables()

Explanation

DSSProject.get_variables() returns the project variables, where the result distinguishes the "standard" (global, bundled) and "local" (instance-only, not bundled) variables. set_variables() updates them. These methods operate at the project level on the public API.

Question 23Dataiku code recipes, datasets, environments and extension boundaries

Through the public API, which DSSProject method starts the creation of a new code recipe (e.g., a Python recipe) programmatically?

  1. project.add_recipe()
  2. project.new_recipe(type, name) / a CodeRecipeCreator Correct answer.
  3. project.make_python()
  4. project.recipe_create()

Explanation

The public API exposes recipe creator objects (such as CodeRecipeCreator / PythonRecipeCreator obtained via new_recipe or new_code_recipe). You set inputs, outputs, and the code payload, then call build()/create() to materialize the recipe. This lets scripts construct Flows programmatically.

Question 24Dataiku code recipes, datasets, environments and extension boundaries

Which dataikuapi class is used in webapp/client code to query a deployed real-time scoring endpoint on an API node?

  1. dataikuapi.DSSClient
  2. dataikuapi.APIDeployer
  3. dataiku.Dataset
  4. dataikuapi.APINodeClient Correct answer.

Explanation

dataikuapi.APINodeClient(url, service_id) connects to a deployed API service on the API node; its predict_record() method sends a feature dictionary to a prediction endpoint and returns the scored result. It is the standard way for code (including Dash webapps) to consume a real-time endpoint.

Question 25Dataiku code recipes, datasets, environments and extension boundaries

An APINodeClient is created and you want a single prediction for one record. Which method do you call?

  1. client.predict_record(endpoint_id, features_dict) Correct answer.
  2. client.score_batch(records)
  3. client.get_dataframe()
  4. client.run_scenario()

Explanation

predict_record(endpoint_id, record) sends one feature dictionary to the named prediction endpoint and returns the result (with a 'result' key containing the prediction). For multiple records there is also predict_records().

Question 26Dataiku code recipes, datasets, environments and extension boundaries

You want to trigger a scenario named DAILY_BUILD on another project from a Python recipe. Which approach is correct?

  1. Import the scenario's Python file and call main()
  2. Set a project variable named RUN_SCENARIO to true
  3. Get a client with dataiku.api_client(), get the project, then call get_scenario("DAILY_BUILD").run_and_wait() or run() Correct answer.
  4. Scenarios can only be started from the UI

Explanation

Use dataiku.api_client() to get a DSSClient for the local instance, obtain the project via get_project(), then call get_scenario("DAILY_BUILD") and run it (e.g., run_and_wait()). The public API exposes scenario objects you can start, list runs for, and inspect.

Question 27Dataiku code recipes, datasets, environments and extension boundaries

What does dataiku.get_custom_variables()['projectKey'] return when called inside a recipe?

  1. The API key of the current user
  2. The name of the current dataset
  3. The project key of the project that owns the running code Correct answer.
  4. The DSS instance license key

Explanation

DSS exposes contextual built-in variables; projectKey resolves to the key of the project hosting the code, so dataiku.get_custom_variables()['projectKey'] returns the current project key. This is handy when writing code that must work across projects.

Question 28Dataiku code recipes, datasets, environments and extension boundaries

Which permission must an API key (or user) have to create or manage code environments through the public API?

  1. Read project content only
  2. Create code envs or Manage all code envs permission Correct answer.
  3. Run scenarios permission
  4. No special permission is needed

Explanation

Code-environment management calls on the public API require an API key with the "Create code envs" or "Manage all code envs" permission. Without the proper permission the call is rejected, reflecting DSS's permission-scoped API keys.

Question 29Dataiku code recipes, datasets, environments and extension boundaries

When modifying a code environment definition through the public API, the documentation cautions that you should call set_definition() with what object?

  1. A brand-new dictionary you construct from scratch
  2. A Pandas DataFrame describing packages
  3. The raw env.json file path
  4. An object you first obtained from get_definition(), then modified Correct answer.

Explanation

You must call set_definition() using the definition object returned by get_definition() (then mutate it), not a freshly built dict. This preserves required internal fields; constructing your own dict risks dropping fields and corrupting the environment definition.

Question 30Dataiku code recipes, datasets, environments and extension boundaries

Which dataiku class lets you read and write a project's saved machine learning model from Python code?

  1. dataiku.Model Correct answer.
  2. dataiku.Dataset
  3. dataiku.Folder
  4. dataiku.api_client only

Explanation

dataiku.Model provides a handle to a saved model in the Flow, letting you get its active version, predictor, and metadata from Python. Coders use it to score in code, inspect versions, or feed a custom webapp.

Question 31Dataiku code recipes, datasets, environments and extension boundaries

Which dataiku.Dataset reading method streams the dataset row by row (each row as a dict), suitable when you do not want Pandas at all?

  1. get_dataframe()
  2. fetch_all()
  3. to_records()
  4. iter_rows() Correct answer.

Explanation

iter_rows() yields the dataset's rows one at a time as dict-like objects, providing a pure-Python streaming read without loading a Pandas DataFrame. It pairs with the row-by-row writer (write_row / write_row_array) for memory-efficient pipelines.

Question 32Dataiku code recipes, datasets, environments and extension boundaries

What is a Dataiku plugin?

  1. A single shared Python function inside one project
  2. A type of scenario trigger
  3. A packaged, reusable extension that can add components such as custom recipes, datasets, processors, macros, and webapps to a DSS instance Correct answer.
  4. A managed folder containing static files

Explanation

A plugin is a packaged extension that bundles one or more components (custom visual recipes, custom datasets/connectors, prepare-recipe processors, macros, custom triggers, webapps, etc.) so they can be installed and reused across projects and instances. Plugins turn code into point-and-click features for other users.

Question 33Dataiku code recipes, datasets, environments and extension boundaries

In a plugin's custom recipe, which JSON file defines the recipe's metadata, input roles, output roles, and parameters that render the configuration form?

  1. recipe.json Correct answer.
  2. plugin.json
  3. params.json
  4. config.yaml

Explanation

Each custom recipe component has a recipe.json with four sections: meta (global description), inputRoles (declared inputs), outputRoles (declared outputs), and params (the parameter form). DSS reads recipe.json to generate the recipe's UI in the Plugin recipes section.

Question 34Dataiku code recipes, datasets, environments and extension boundaries

Within a plugin custom recipe's Python code, which helpers from dataiku.customrecipe are used to resolve the datasets bound to declared input/output roles?

  1. dataiku.Dataset.roles()
  2. get_input_names_for_role() and get_output_names_for_role() Correct answer.
  3. read_role() and write_role()
  4. input() and output()

Explanation

dataiku.customrecipe.get_input_names_for_role("role") and get_output_names_for_role("role") return the dataset names the user mapped to each declared role, and get_recipe_config() returns the parameter values. The code then builds dataiku.Dataset handles from those names.

Question 35Dataiku code recipes, datasets, environments and extension boundaries

A plugin needs a setting (like API credentials) shared across several of its components and configured by an admin at the instance or project level. Which parameter mechanism is recommended?

  1. A PRESET parameter, whose values can be entered at instance, project, or component level Correct answer.
  2. A hard-coded constant in each component
  3. A scenario reporter
  4. A managed folder

Explanation

Plugin presets store shared settings (such as credentials) that multiple components can reference. Admins enter preset values at the instance level (plugin settings), project admins at the project level (Settings > Plugins presets), or, if allowed, the user at component level. This avoids duplicating sensitive configuration.

Question 36Dataiku code recipes, datasets, environments and extension boundaries

In recipe.json, which field makes a custom recipe directly selectable from the Flow when a user has a Dataset selected?

  1. "datasetInput": true
  2. "flowEnabled": true
  3. "selectableFromDataset": true Correct answer.
  4. "showInFlow": true

Explanation

Adding "selectableFromDataset" to the recipe's JSON lets users launch the recipe directly from a selected Dataset in the Flow. Analogous fields exist for folders (selectableFromFolder), saved models (selectableFromMLModel), and promptable GenAI models.

Question 37Dataiku code recipes, datasets, environments and extension boundaries

What is the difference between plugin.json and recipe.json in a plugin?

  1. They are identical and interchangeable
  2. recipe.json is generated automatically and never edited
  3. plugin.json holds the Python code, recipe.json holds the HTML
  4. plugin.json describes the whole plugin (id, label, version, author, icon); recipe.json configures a single custom recipe component's roles and parameters Correct answer.

Explanation

There is exactly one plugin.json per plugin, describing the plugin globally (id, label, version, author, icon, recipesCategory). Each custom recipe has its own recipe.json defining that component's meta, input/output roles, and parameters. They serve different scopes.

Question 38Dataiku code recipes, datasets, environments and extension boundaries

In a plugin recipe's params array, which special parameter types let the user pick one or more columns from an input dataset?

  1. STRING and TEXTAREA
  2. COLUMN and COLUMNS Correct answer.
  3. INT and DOUBLE
  4. SELECT and MULTISELECT

Explanation

Plugin recipe parameters include COLUMN (pick a single column) and COLUMNS (pick multiple columns) types, which render column pickers bound to a declared input dataset. This lets non-coders configure which columns the recipe operates on.

Question 39Dataiku code recipes, datasets, environments and extension boundaries

How do you typically start building a plugin custom recipe from an existing Python recipe in a project?

  1. Manually create every plugin file by hand with no tooling
  2. Rename the recipe file to recipe.json
  3. Upload the recipe to the Dataiku store
  4. Use the recipe's Actions menu to convert it into a plugin recipe, supplying a plugin id and recipe id; DSS scaffolds the folder structure Correct answer.

Explanation

Dataiku lets you convert an existing code recipe into a plugin recipe; you provide a plugin id and recipe id, and DSS generates the plugin folder tree (custom-recipes/{id}/recipe.json and recipe.py with helpful starter comments). You then declare roles/params and parameterize the code.

Question 40Dataiku code recipes, datasets, environments and extension boundaries

Which permission is required for a user to develop plugins on a DSS instance?

  1. Develop plugins (a specific instance-level permission) Correct answer.
  2. Write project content
  3. Run scenarios
  4. Read dashboards

Explanation

Developing plugins (creating and editing plugin components in the plugin development environment) requires the "Develop plugins" permission on the instance. Project-level permissions like Write project content are also needed to test the recipe inside a project, but plugin development itself is gated by the Develop plugins permission.

Question 41Dataiku code recipes, datasets, environments and extension boundaries

In plugin.json, what does the "recipesCategory" field control?

  1. The Python version the plugin uses
  2. The category (e.g., visual, code, genai, or other) under which the plugin's recipes appear in the recipe selection panel Correct answer.
  3. Which datasets the plugin can read
  4. The plugin's semantic version number

Explanation

recipesCategory in plugin.json determines where the plugin's recipe components are grouped in the right-hand recipe panel; allowed values are visual, code, genai, or other. If left empty, the recipes appear simply under the generic Plugin recipes category.

Question 42Dataiku code recipes, datasets, environments and extension boundaries

Within a plugin custom recipe's recipe.py, which helper returns the dictionary of parameter values the user configured in the recipe form?

  1. dataiku.get_custom_variables()
  2. get_input_names_for_role()
  3. get_recipe_config() Correct answer.
  4. get_plugin_config()

Explanation

dataiku.customrecipe.get_recipe_config() returns a dict of the parameter values the user set in the recipe's configuration form (declared in recipe.json's params). The code reads these to drive its behavior instead of hard-coding values.

Question 43Dataiku code recipes, datasets, environments and extension boundaries

A plugin contains both a custom recipe and a custom dataset connector. How many plugin.json files does this plugin have?

  1. One per component, so two
  2. Exactly one plugin.json for the whole plugin Correct answer.
  3. Zero; plugin.json is optional
  4. Three: one global and one per component

Explanation

A plugin has exactly one plugin.json describing the plugin as a whole, regardless of how many components it bundles. Each component (recipe, dataset, macro, webapp) has its own component-level JSON (e.g., recipe.json), but there is a single plugin.json at the root.

Question 44Dataiku code recipes, datasets, environments and extension boundaries

Besides custom recipes and datasets, which of the following is a valid plugin component type in Dataiku?

  1. A custom git branch
  2. A replacement for the Flow view
  3. A custom SQL database engine
  4. A macro (a parameterized administrative or utility action runnable from a project) Correct answer.

Explanation

Macros are a valid plugin component: parameterized Python actions exposed in a project that perform tasks such as administrative operations, data exports, or bulk changes. Other plugin components include custom datasets/connectors, prepare-recipe processors, custom triggers, custom fields, and webapps.

Question 45Dataiku scenarios, variables, bundles and API-service deployment

What are the three main components that make up a Dataiku scenario?

  1. Steps, triggers, and reporters Correct answer.
  2. Datasets, recipes, and connections
  3. Inputs, outputs, and parameters
  4. Models, folders, and notebooks

Explanation

A scenario consists of steps (the ordered actions to take), triggers (the conditions that launch the scenario), and reporters (channels that send alerts about scenario activity). Understanding this structure is central to automating a Dataiku project.

Question 46Dataiku scenarios, variables, bundles and API-service deployment

Which scenario trigger launches the scenario at regular intervals such as every day at 22:00?

  1. Dataset change trigger
  2. SQL query change trigger
  3. Time-based trigger Correct answer.
  4. Python custom trigger

Explanation

A time-based trigger fires at regular periods (monthly, weekly, daily, or hourly) at a chosen time point. For example, a daily time-based trigger set to 22:00 runs the scenario every night at 10 PM.

Question 47Dataiku scenarios, variables, bundles and API-service deployment

You need a scenario to run whenever the data in an externally-managed SQL table changes. Why is a "dataset change" trigger insufficient, and what should you use instead?

  1. Dataset change works fine for SQL tables; nothing else is needed
  2. Use a time-based trigger only
  3. Dataset change triggers only look at the dataset's settings/file metadata and won't detect SQL data changes; use a SQL query change trigger that returns a value (e.g., COUNT or MAX) which changes with the data Correct answer.
  4. SQL tables cannot trigger scenarios at all

Explanation

A SQL-query change trigger compares its actual query results, which can observe meaningful SQL-data changes that a metadata-only signal misses. A count or maximum does not detect every edit, such as a value update preserving both statistics. Select a justified observation and test representative changes under the actual trigger contract.

Question 48Dataiku scenarios, variables, bundles and API-service deployment

Precisely when does a SQL query change trigger fire?

  1. Every time the query runs, regardless of result
  2. When the query's result differs from the result of the previous execution of that same query Correct answer.
  3. Only when the query returns zero rows
  4. When the query throws an error

Explanation

The SQL query change trigger runs the query at the configured periodicity and stores the result. It fires only when the new result differs from the stored one. That is why you write queries returning an aggregate (e.g., COUNT or MAX) so ordering noise doesn't cause false triggers and real changes are detected.

Question 49Dataiku scenarios, variables, bundles and API-service deployment

A scenario has multiple active triggers. How are they evaluated?

  1. All triggers must be true simultaneously for the scenario to run (AND logic)
  2. Triggers are ignored unless the scenario is run manually
  3. Only the first trigger is ever evaluated
  4. Each trigger is evaluated independently; the scenario runs when ANY trigger condition is true (OR logic) Correct answer.

Explanation

When a scenario has several active triggers, their conditions are evaluated independently and the scenario launches when any one of them is satisfied (OR semantics). The scenario must also be marked active for triggers to be evaluated at all.

Question 50Dataiku scenarios, variables, bundles and API-service deployment

Which scenario step would you use to run arbitrary custom logic in Python as part of the scenario's actions?

  1. Execute Python code step Correct answer.
  2. Build / Train step
  3. Send message step
  4. Compute metrics step

Explanation

The Execute Python code step runs custom Python within a step-based scenario, useful for logic that built-in steps don't cover. (Custom Python scenarios go further, replacing the whole step engine with code.) Other steps include Build/Train, Execute SQL, Set variables, and Run scenario.