Private endpoints concept in Azure - Time & Space Complexity

Time Complexity: Private endpoints concept

O(n)

Understanding Time Complexity

We want to understand how the time to create private endpoints changes as we add more endpoints.

How does the number of private endpoints affect the total setup time?

Scenario Under Consideration

Analyze the time complexity of creating multiple private endpoints in Azure.

// Loop to create private endpoints
for (int i = 0; i < n; i++) {
    var privateEndpoint = new PrivateEndpoint()
    {
        Name = $"endpoint-{i}",
        SubnetId = subnetId,
        PrivateLinkServiceConnections = new List<PrivateLinkServiceConnection> {
            new PrivateLinkServiceConnection { Name = $"pls-conn-{i}", PrivateLinkServiceId = serviceId }
        }
    };
    CreatePrivateEndpoint(privateEndpoint);
}
    

This code creates n private endpoints, each connecting to a service via a private link.

Identify Repeating Operations

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

• Primary operation: Creating a private endpoint resource via API call.
• How many times: Exactly n times, once per endpoint.

How Execution Grows With Input

Each new private endpoint requires a separate creation call, so the total time grows as we add more endpoints.

Input Size (n)	Approx. API Calls/Operations
10	10
100	100
1000	1000

Pattern observation: The number of operations grows directly with the number of endpoints.

Final Time Complexity

Time Complexity: O(n)

This means the time to create private endpoints increases linearly as you add more endpoints.

Common Mistake

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

[OK] Correct: Each endpoint creation is a separate API call and provisioning step, so total time adds up with each one.

Interview Connect

Understanding how resource creation scales helps you design efficient cloud setups and explain your reasoning clearly in interviews.

Self-Check

"What if we created multiple private endpoints in parallel instead of one after another? How would the time complexity change?"