Interview Guides

Validate Low-Code Workflow Deployment Order | Dataford Interview Questions - Dataford - Ace your Interview

Validate Low-Code Workflow Deployment Order

Medium

Coding

Problem

Problem Narrative

You’re on a fintech risk team supporting an internal low-code/no-code platform used by 8,000 ops analysts to ship fraud-review workflows. A workflow is built from reusable “blocks” (KYC check, device fingerprint, sanctions screening). Before deployment, the platform must ensure blocks can be executed in a valid order and flag configuration mistakes that would cause runtime failures.

Each workflow is described by directed dependencies: if block A must run before block B, you’ll receive a pair [A, B]. Some workflows are huge (tens of thousands of blocks) and are deployed multiple times per day, so you need an efficient validator.

Task

Given:

blocks: a list of unique block IDs (strings)
dependencies: a list of pairs [before, after] meaning before -> after

Return a list representing a valid execution order of all blocks such that every dependency is satisfied.

If no valid order exists (because of a cycle), return an empty list [].

Additional Requirements

If multiple valid orders exist, return the one that is lexicographically smallest (string order) among all valid topological orders.
Dependencies may reference blocks only from blocks (assume inputs are consistent).

Examples

Example 1

Input:

blocks = ["kyc", "device", "sanctions", "score"]
dependencies = [["kyc", "score"], ["device", "score"], ["sanctions", "score"]]

Output:

["device", "kyc", "sanctions", "score"]

Explanation: score must come after kyc, device, and sanctions. Among all valid orders, starting with device is lexicographically smallest.

Example 2

Input:

blocks = ["a", "b", "c"]
dependencies = [["a", "b"], ["b", "c"], ["c", "a"]]

Output:

[]

Explanation: The dependencies form a cycle, so no deployment order exists.

Constraints

1 <= len(blocks) <= 2 * 10^4
0 <= len(dependencies) <= 2 * 10^5
Block IDs are lowercase strings of length 1..20

Notes

Blocks with no prerequisites can run first.
If the workflow is valid, your output must include every block exactly once.
Aim for near-linear performance; quadratic solutions will time out at peak scale.

Examples

Example 1

Input

blocks = ["kyc", "device", "sanctions", "score"], dependencies = [["kyc", "score"], ["device", "score"], ["sanctions", "score"]]

Output["device", "kyc", "sanctions", "score"]WhyRunnable initially: device, kyc, sanctions. Pick lexicographically smallest each time; score becomes runnable only after all three are scheduled.

Example 2

Inputblocks = ["a", "b", "c"], dependencies = [["a", "b"], ["b", "c"], ["c", "a"]]Output[]WhyNo node ever reaches indegree 0 after processing starts because the graph contains a directed cycle.

Constraints

1 <= len(blocks) <= 2 * 10^4
0 <= len(dependencies) <= 2 * 10^5
blocks contains unique strings
Each dependency is a pair [before, after] with before and after in blocks
Block IDs are lowercase strings of length 1..20

Function Signature

def deployment_order(blocks: list[str], dependencies: list[list[str]]) -> list[str]:

Problem

Problem Narrative

Task

Given:

blocks: a list of unique block IDs (strings)
dependencies: a list of pairs [before, after] meaning before -> after

Return a list representing a valid execution order of all blocks such that every dependency is satisfied.

If no valid order exists (because of a cycle), return an empty list [].

Additional Requirements

If multiple valid orders exist, return the one that is lexicographically smallest (string order) among all valid topological orders.
Dependencies may reference blocks only from blocks (assume inputs are consistent).

Examples

Example 1

Input:

blocks = ["kyc", "device", "sanctions", "score"]
dependencies = [["kyc", "score"], ["device", "score"], ["sanctions", "score"]]

Output:

["device", "kyc", "sanctions", "score"]

Explanation: score must come after kyc, device, and sanctions. Among all valid orders, starting with device is lexicographically smallest.

Example 2

Input:

blocks = ["a", "b", "c"]
dependencies = [["a", "b"], ["b", "c"], ["c", "a"]]

Output:

[]

Explanation: The dependencies form a cycle, so no deployment order exists.

Constraints

1 <= len(blocks) <= 2 * 10^4
0 <= len(dependencies) <= 2 * 10^5
Block IDs are lowercase strings of length 1..20

Notes

Blocks with no prerequisites can run first.
If the workflow is valid, your output must include every block exactly once.
Aim for near-linear performance; quadratic solutions will time out at peak scale.

Examples

Example 1

Input

blocks = ["kyc", "device", "sanctions", "score"], dependencies = [["kyc", "score"], ["device", "score"], ["sanctions", "score"]]

Output["device", "kyc", "sanctions", "score"]WhyRunnable initially: device, kyc, sanctions. Pick lexicographically smallest each time; score becomes runnable only after all three are scheduled.

Example 2

Inputblocks = ["a", "b", "c"], dependencies = [["a", "b"], ["b", "c"], ["c", "a"]]Output[]WhyNo node ever reaches indegree 0 after processing starts because the graph contains a directed cycle.

Constraints

1 <= len(blocks) <= 2 * 10^4
0 <= len(dependencies) <= 2 * 10^5
blocks contains unique strings
Each dependency is a pair [before, after] with before and after in blocks
Block IDs are lowercase strings of length 1..20

Function Signature

def deployment_order(blocks: list[str], dependencies: list[list[str]]) -> list[str]:

Practice Python

Python 3.10

Open on desktop for the full Python editor with syntax highlighting and autocomplete.

Up next

Deterministic Task Execution OrderHard Optimal DAG Job Scheduling MakespanMedium Minimal Gate Plan with OR-RulesMedium

Next question

Validate Low-Code Workflow Deployment Order

Medium

Coding

Problem

Problem Narrative

Task

Given:

blocks: a list of unique block IDs (strings)
dependencies: a list of pairs [before, after] meaning before -> after

Return a list representing a valid execution order of all blocks such that every dependency is satisfied.

If no valid order exists (because of a cycle), return an empty list [].

Additional Requirements

If multiple valid orders exist, return the one that is lexicographically smallest (string order) among all valid topological orders.
Dependencies may reference blocks only from blocks (assume inputs are consistent).

Examples

Example 1

Input:

blocks = ["kyc", "device", "sanctions", "score"]
dependencies = [["kyc", "score"], ["device", "score"], ["sanctions", "score"]]

Output:

["device", "kyc", "sanctions", "score"]

Explanation: score must come after kyc, device, and sanctions. Among all valid orders, starting with device is lexicographically smallest.

Example 2

Input:

blocks = ["a", "b", "c"]
dependencies = [["a", "b"], ["b", "c"], ["c", "a"]]

Output:

[]

Explanation: The dependencies form a cycle, so no deployment order exists.

Constraints

1 <= len(blocks) <= 2 * 10^4
0 <= len(dependencies) <= 2 * 10^5
Block IDs are lowercase strings of length 1..20

Notes

Blocks with no prerequisites can run first.
If the workflow is valid, your output must include every block exactly once.
Aim for near-linear performance; quadratic solutions will time out at peak scale.

Examples

Example 1

Input

blocks = ["kyc", "device", "sanctions", "score"], dependencies = [["kyc", "score"], ["device", "score"], ["sanctions", "score"]]

Output["device", "kyc", "sanctions", "score"]WhyRunnable initially: device, kyc, sanctions. Pick lexicographically smallest each time; score becomes runnable only after all three are scheduled.

Example 2

Inputblocks = ["a", "b", "c"], dependencies = [["a", "b"], ["b", "c"], ["c", "a"]]Output[]WhyNo node ever reaches indegree 0 after processing starts because the graph contains a directed cycle.

Constraints

1 <= len(blocks) <= 2 * 10^4
0 <= len(dependencies) <= 2 * 10^5
blocks contains unique strings
Each dependency is a pair [before, after] with before and after in blocks
Block IDs are lowercase strings of length 1..20

Function Signature

def deployment_order(blocks: list[str], dependencies: list[list[str]]) -> list[str]:

Problem

Problem Narrative

Task

Given:

blocks: a list of unique block IDs (strings)
dependencies: a list of pairs [before, after] meaning before -> after

Return a list representing a valid execution order of all blocks such that every dependency is satisfied.

If no valid order exists (because of a cycle), return an empty list [].

Additional Requirements

If multiple valid orders exist, return the one that is lexicographically smallest (string order) among all valid topological orders.
Dependencies may reference blocks only from blocks (assume inputs are consistent).

Examples

Example 1

Input:

blocks = ["kyc", "device", "sanctions", "score"]
dependencies = [["kyc", "score"], ["device", "score"], ["sanctions", "score"]]

Output:

["device", "kyc", "sanctions", "score"]

Explanation: score must come after kyc, device, and sanctions. Among all valid orders, starting with device is lexicographically smallest.

Example 2

Input:

blocks = ["a", "b", "c"]
dependencies = [["a", "b"], ["b", "c"], ["c", "a"]]

Output:

[]

Explanation: The dependencies form a cycle, so no deployment order exists.

Constraints

1 <= len(blocks) <= 2 * 10^4
0 <= len(dependencies) <= 2 * 10^5
Block IDs are lowercase strings of length 1..20

Notes

Blocks with no prerequisites can run first.
If the workflow is valid, your output must include every block exactly once.
Aim for near-linear performance; quadratic solutions will time out at peak scale.

Examples

Example 1

Input

blocks = ["kyc", "device", "sanctions", "score"], dependencies = [["kyc", "score"], ["device", "score"], ["sanctions", "score"]]

Output["device", "kyc", "sanctions", "score"]WhyRunnable initially: device, kyc, sanctions. Pick lexicographically smallest each time; score becomes runnable only after all three are scheduled.

Example 2

Inputblocks = ["a", "b", "c"], dependencies = [["a", "b"], ["b", "c"], ["c", "a"]]Output[]WhyNo node ever reaches indegree 0 after processing starts because the graph contains a directed cycle.

Constraints

1 <= len(blocks) <= 2 * 10^4
0 <= len(dependencies) <= 2 * 10^5
blocks contains unique strings
Each dependency is a pair [before, after] with before and after in blocks
Block IDs are lowercase strings of length 1..20

Function Signature

def deployment_order(blocks: list[str], dependencies: list[list[str]]) -> list[str]:

Practice Python

Python 3.10

Open on desktop for the full Python editor with syntax highlighting and autocomplete.

Up next

Deterministic Task Execution OrderHard Optimal DAG Job Scheduling MakespanMedium Minimal Gate Plan with OR-RulesMedium

Next question