🔥 Google VO Real Question: Config Diff System - 3 Followups That Keep Escalating!

Recently, this Config Diff System question has been frequently appearing in Google VO. What seems like a simple dictionary comparison is actually a progressively challenging engineering design problem.

Many candidates breathe a sigh of relief after finishing the first version, only to be caught off guard by 3 rounds of Followups. Today, oavoservice breaks down this problem completely, from basic to production-level implementation.

---

📋 Problem Description

Given two nested dictionaries left and right, compare them and output a result dictionary with three sections:

1. added — Keys that exist in right but not in left
2. deleted — Keys that exist in left but not in right
3. edited — Keys that exist in both but have different values

---

🎯 Interview Flow Breakdown

Step 1: Clarify (Critical!)

The interviewer will first ask you to clarify. Make sure to ask:

• Q: Can values be nested dictionaries?
• A: Initially no need to consider nested, all values are primitive types
• Q: Can values be list/array?
• A: No need to consider

💡 oavoservice Tip: The clarification phase determines your first version's complexity. Start simple and leave room for Followups.

---

✅ Basic Version: Flat Dictionary Comparison

Approach

Three passes:

1. Iterate through left keys to find deleted and edited
2. Iterate through right keys to find added

oavoservice Perfect Solution

def config_diff(left: dict, right: dict) -> dict:
    result = {
        "added": {},
        "deleted": {},
        "edited": {}
    }
    
    # Find deleted and edited
    for key in left:
        if key not in right:
            result["deleted"][key] = left[key]
        elif left[key] != right[key]:
            result["edited"][key] = {"old": left[key], "new": right[key]}
    
    # Find added
    for key in right:
        if key not in left:
            result["added"][key] = right[key]
    
    return result

Example

left = {"a": 1, "b": 2, "c": 3}
right = {"a": 1, "b": 5, "d": 4}

# Output:
{
    "added": {"d": 4},
    "deleted": {"c": 3},
    "edited": {"b": {"old": 2, "new": 5}}
}

Complexity Analysis

• Time: O(n + m), where n and m are the number of keys in left and right
• Space: O(n + m) for storing results

Test Case Design

The interviewer will ask how you would design test cases:

1. Empty dicts — {}, {} → all empty
2. Identical — {"a": 1}, {"a": 1} → all empty
3. Completely different — {"a": 1}, {"b": 2} → deleted + added
4. Only edited — {"a": 1}, {"a": 2}
5. Mixed cases — added + deleted + edited all present

---

🚀 Followup 1: Support Nested Dictionary

Problem Change

Now values can be nested dictionaries, requiring recursive comparison.

Core Approach

• If both sides are dict → recursive comparison
• If one side is dict and other is not → treat as edited
• Other cases → basic comparison logic

oavoservice Perfect Solution

def config_diff_nested(left: dict, right: dict) -> dict:
    result = {
        "added": {},
        "deleted": {},
        "edited": {}
    }
    
    all_keys = set(left.keys()) | set(right.keys())
    
    for key in all_keys:
        left_val = left.get(key)
        right_val = right.get(key)
        
        if key not in left:
            # Added
            result["added"][key] = right_val
        elif key not in right:
            # Deleted
            result["deleted"][key] = left_val
        elif isinstance(left_val, dict) and isinstance(right_val, dict):
            # Recursively compare nested dicts
            nested_diff = config_diff_nested(left_val, right_val)
            # Only add non-empty results
            if any(nested_diff.values()):
                result["edited"][key] = nested_diff
        elif left_val != right_val:
            # Values differ (including type mismatch)
            result["edited"][key] = {"old": left_val, "new": right_val}
    
    return result

Example

left = {
    "db": {"host": "localhost", "port": 3306},
    "cache": {"enabled": True}
}
right = {
    "db": {"host": "prod.db.com", "port": 3306},
    "cache": {"enabled": True, "ttl": 300}
}

# Output:
{
    "added": {},
    "deleted": {},
    "edited": {
        "db": {
            "added": {},
            "deleted": {},
            "edited": {"host": {"old": "localhost", "new": "prod.db.com"}}
        },
        "cache": {
            "added": {"ttl": 300},
            "deleted": {},
            "edited": {}
        }
    }
}

---

🚀 Followup 2: Support List as Value

Problem Change

Now values can be lists. How do you handle this?

Discussion Points (What the Interviewer Wants to Hear)

The interviewer may not require implementation, but wants to hear your design thinking:

1. Simple Approach: Whole List Comparison

   • Compare two lists directly with ==
   • If different, mark as edited with old/new

2. Complex Approach: Element-Level Comparison

   • Need to define what "same element" means
   • If list elements are dicts, may need an ID field for matching
   • Similar to React's key concept

3. Order Sensitive vs Order Insensitive

   • Are [1, 2, 3] and [3, 2, 1] the same?

oavoservice Recommended Implementation (Whole Comparison)

def config_diff_with_list(left: dict, right: dict) -> dict:
    result = {"added": {}, "deleted": {}, "edited": {}}
    
    all_keys = set(left.keys()) | set(right.keys())
    
    for key in all_keys:
        left_val = left.get(key)
        right_val = right.get(key)
        
        if key not in left:
            result["added"][key] = right_val
        elif key not in right:
            result["deleted"][key] = left_val
        elif isinstance(left_val, dict) and isinstance(right_val, dict):
            nested_diff = config_diff_with_list(left_val, right_val)
            if any(nested_diff.values()):
                result["edited"][key] = nested_diff
        elif isinstance(left_val, list) and isinstance(right_val, list):
            # Whole list comparison
            if left_val != right_val:
                result["edited"][key] = {"old": left_val, "new": right_val}
        elif left_val != right_val:
            result["edited"][key] = {"old": left_val, "new": right_val}
    
    return result

---

🚀 Followup 3: Alternative Output Structure

Problem Change

The interviewer may request a different output format, such as:

Flat Path Format:

{
    "added": ["cache.ttl"],
    "deleted": ["old_key"],
    "edited": ["db.host"]
}

Or Detailed Format with Paths:

[
    {"path": "db.host", "type": "edited", "old": "localhost", "new": "prod.db.com"},
    {"path": "cache.ttl", "type": "added", "value": 300}
]

oavoservice Perfect Solution (Flat Path Version)

def config_diff_flat(left: dict, right: dict, prefix: str = "") -> dict:
    result = {"added": [], "deleted": [], "edited": []}
    
    all_keys = set(left.keys()) | set(right.keys())
    
    for key in all_keys:
        path = f"{prefix}.{key}" if prefix else key
        left_val = left.get(key)
        right_val = right.get(key)
        
        if key not in left:
            result["added"].append(path)
        elif key not in right:
            result["deleted"].append(path)
        elif isinstance(left_val, dict) and isinstance(right_val, dict):
            nested = config_diff_flat(left_val, right_val, path)
            result["added"].extend(nested["added"])
            result["deleted"].extend(nested["deleted"])
            result["edited"].extend(nested["edited"])
        elif left_val != right_val:
            result["edited"].append(path)
    
    return result

---

💡 What the Interviewer is Really Testing

This problem tests more than algorithms:

1. Clarification Skills — Ask before you code
2. Recursive Thinking — Handling nested structures
3. Edge Cases — Type mismatches, null handling
4. Engineering Mindset — Output format design, extensibility
5. Trade-off Discussion — Multiple approaches for List comparison

---

🤯 Common Pitfalls

• First version too complex — Considering nested from the start wastes time
• Recursive return value issues — Handling empty nested results
• Missing type checks — One side is dict, other is not
• Shallow Followup discussion — Only mentioning one approach for List comparison

---

🚀 oavoservice: Your Google VO Full Support

Google interviews are characterized by layered Followups — one problem can be explored for 30-45 minutes. Many candidates do well on the basic version but get stumped during Followups.

oavoservice's Real-time VO Assistance helps you:

✅ Real-time strategy hints — Anticipate Followup directions

✅ Edge case reminders — Don't miss critical cases

✅ Discussion point preparation — Trade-off analysis support

✅ Non-intrusive — Compatible with Google Meet / Zoom

Don't let a Followup cost you your Google offer.

We consistently provide professional interview assistance services for major tech companies like Google, Meta, Amazon, and TikTok. Feel free to contact us if you're interested.

👉 Add WeChat now: Coding0201

Secure your Google interview opportunity!