RDS supported engines in AWS - Time & Space Complexity

Time Complexity: RDS supported engines

O(n)

Understanding Time Complexity

We want to understand how the time to list supported RDS engines changes as the number of engines grows.

How does the number of supported engines affect the time to get their details?

Scenario Under Consideration

Analyze the time complexity of the following operation sequence.

// List all supported RDS engines
const engines = await rds.describeDBEngineVersions().promise();

// For each engine, get details
for (const engine of engines.DBEngineVersions) {
  console.log(engine.Engine, engine.EngineVersion);
}
    

This code fetches all supported RDS database engines and prints their names and versions.

Identify Repeating Operations

Identify the API calls, resource provisioning, data transfers that repeat.

• Primary operation: One API call to describeDBEngineVersions to get all engines.
• How many times: Called once regardless of number of engines.
• Data processing: Loop over each engine in memory to print details.

How Execution Grows With Input

The API call happens once, but the processing loops over each engine.

Input Size (n)	Approx. API Calls/Operations
10	1 API call + 10 print operations
100	1 API call + 100 print operations
1000	1 API call + 1000 print operations

Pattern observation: API calls stay the same, but processing grows linearly with number of engines.

Final Time Complexity

Time Complexity: O(n)

This means the time grows linearly with the number of supported RDS engines.

Common Mistake

[X] Wrong: "The API call time grows with the number of engines, so more engines means more API calls."

[OK] Correct: The API call returns all engines at once, so only one call is needed regardless of engine count.

Interview Connect

Understanding how API calls and data processing scale helps you design efficient cloud solutions and answer real-world questions confidently.

Self-Check

"What if we made a separate API call for each engine to get more details? How would the time complexity change?"