Storing keys and certificates in Azure - Time & Space Complexity

Time Complexity: Storing keys and certificates

O(n)

Understanding Time Complexity

When storing keys and certificates in Azure, it's important to understand how the time to complete operations changes as you store more items.

We want to know how the number of stored secrets affects the time it takes to save or retrieve them.

Scenario Under Consideration

Analyze the time complexity of the following operation sequence.

// Create a Key Vault client
var client = new SecretClient(new Uri(keyVaultUrl), credential);

// Store multiple secrets (keys or certificates)
foreach (var secret in secretsList) {
    await client.SetSecretAsync(secret.Name, secret.Value);
}

// Retrieve a secret by name
var secret = await client.GetSecretAsync(secretName);
    

This sequence stores multiple secrets one by one and retrieves a single secret by its name.

Identify Repeating Operations

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

• Primary operation: Calling SetSecretAsync to store each secret.
• How many times: Once for each secret in the list.
• Retrieval operation: Calling GetSecretAsync once to get a secret by name.

How Execution Grows With Input

As the number of secrets to store increases, the number of API calls grows directly with it.

Input Size (n)	Approx. Api Calls/Operations
10	10 calls to store + 1 call to retrieve = 11
100	100 calls to store + 1 call to retrieve = 101
1000	1000 calls to store + 1 call to retrieve = 1001

Pattern observation: The total operations increase linearly as you add more secrets to store.

Final Time Complexity

Time Complexity: O(n)

This means the time to store secrets grows in direct proportion to how many secrets you have.

Common Mistake

[X] Wrong: "Storing multiple secrets happens all at once, so time stays the same no matter how many secrets."

[OK] Correct: Each secret requires a separate API call, so time grows with the number of secrets.

Interview Connect

Understanding how storing and retrieving secrets scales helps you design systems that stay responsive as they grow.

Self-Check

What if you batch multiple secrets into a single API call? How would the time complexity change?