What separates a senior microservices answer from a staff/principal-level answer?

package com.bank.service;

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import java.math.BigDecimal;

public class TransferService {

    // Senior-level: correct resilience design
    @CircuitBreaker(name = "fraud", fallbackMethod = "holdForReview")
    public String checkFraud(String accountId, BigDecimal amount) {
        // Calls fraud service with timeout, retry, fallback
        return "APPROVED";
    }

    public String holdForReview(String accountId, BigDecimal amount, Throwable t) {
        System.out.println("Fraud service down. Holding transfer for manual review.");
        return "HELD_FOR_REVIEW";
    }
}

Expected behavior:
When fraud service is healthy: returns APPROVED
When fraud service is down: circuit breaker opens, falls back to HELD_FOR_REVIEW

package com.bank.architecture;

public class StaffLevelDimensions {
    public static void main(String[] args) {
        System.out.println("Dimension 1: TEAMS -- boundaries match organization?");
        System.out.println("Dimension 2: COST -- operational tax justified?");
        System.out.println("Dimension 3: INCIDENT -- debuggable at 3 AM by a new hire?");
        System.out.println("Dimension 4: EVOLUTION -- reversible? Contracts safe?");
    }
}

Expected output:
Dimension 1: TEAMS -- boundaries match organization?
Dimension 2: COST -- operational tax justified?
Dimension 3: INCIDENT -- debuggable at 3 AM by a new hire?
Dimension 4: EVOLUTION -- reversible? Contracts safe?

package com.bank.architecture;

public class ConwaysLaw {
    public static void main(String[] args) {
        int services = 5;
        int teams    = 1;  // one team owns all 5 services

        // WRONG: splitting one team's cohesive work into 5 services
        System.out.println(services + " services owned by " + teams + " team");
        System.out.println("Result: " + services + " pipelines, " + services
            + " on-call rotations, " + services + " runbooks");
        System.out.println("Coordination overhead exceeds independence benefit.");

        // CORRECT: service boundaries match team boundaries
        System.out.println("\nCORRECT: 1 team = 1 service (or co-owned group)");
    }
}

Expected output:
5 services owned by 1 team
Result: 5 pipelines, 5 on-call rotations, 5 runbooks
Coordination overhead exceeds independence benefit.

CORRECT: 1 team = 1 service (or co-owned group)

package com.bank.architecture;

public class PlatformCost {
    public static void main(String[] args) {
        String[] permanentCosts = {
            "Service discovery (Eureka, Consul)",
            "Distributed tracing (Zipkin, Jaeger)",
            "Message broker (Kafka) + schema registry",
            "Per-service CI/CD pipelines",
            "Cross-service consistency (sagas, outbox)",
            "Per-service monitoring dashboards"
        };
        System.out.println("Permanent operational tax (paid on EVERY change):");
        for (String cost : permanentCosts) {
            System.out.println("  - " + cost);
        }
    }
}

Expected output:
Permanent operational tax (paid on EVERY change):
  - Service discovery (Eureka, Consul)
  - Distributed tracing (Zipkin, Jaeger)
  - Message broker (Kafka) + schema registry
  - Per-service CI/CD pipelines
  - Cross-service consistency (sagas, outbox)
  - Per-service monitoring dashboards

package com.bank.architecture;

public class IncidentReadiness {
    public static void main(String[] args) {
        boolean hasCorrelationIds = true;
        boolean hasRunbooks       = true;
        boolean newHireCanDebug   = false;
        boolean clearOwnership    = false;

        if (!newHireCanDebug || !clearOwnership) {
            System.out.println("FAIL: only the designer can debug this system.");
            System.out.println("At 3 AM under stress, this architecture is fragile.");
        }
    }
}

Expected output:
FAIL: only the designer can debug this system.
At 3 AM under stress, this architecture is fragile.

package com.bank.architecture;

public class EvolutionSafety {
    public static void main(String[] args) {
        boolean contractsVersioned     = true;
        boolean hasContractTests       = false;
        boolean canMergeBackIfNeeded   = false;

        System.out.println("Contracts versioned: " + contractsVersioned);
        System.out.println("Consumer-driven contract tests: " + hasContractTests);
        System.out.println("Can merge back if split is wrong: " + canMergeBackIfNeeded);

        if (!hasContractTests || !canMergeBackIfNeeded) {
            System.out.println("WARNING: architecture is not safely evolvable.");
        }
    }
}

Expected output:
Contracts versioned: true
Consumer-driven contract tests: false
Can merge back if split is wrong: false
WARNING: architecture is not safely evolvable.

package com.bank.architecture;

public class DefiningShift {
    public static void main(String[] args) {
        System.out.println("Senior verdict:    'Yes, well designed.'");
        System.out.println("Principal verdict: 'No, permanent cost too high.'");
        System.out.println("The step between levels is NOT more patterns.");
        System.out.println("It is subordinating technical design to organizational health.");
    }
}

Expected output:
Senior verdict:    'Yes, well designed.'
Principal verdict: 'No, permanent cost too high.'
The step between levels is NOT more patterns.
It is subordinating technical design to organizational health.

package com.bank.architecture;

public class CommonMistakes {
    public static void main(String[] args) {
        // WRONG: evaluating only technical correctness
        System.out.println("WRONG: 'The design is technically perfect.'");
        System.out.println("But: team boundaries do not match service boundaries");
        System.out.println("But: the tax is not justified for the workload");
        System.out.println("But: a new hire cannot debug 8 services under pressure");

        // CORRECT: evaluate on BOTH axes
        System.out.println("\nCORRECT: evaluate technical correctness");
        System.out.println("AND organizational sustainability");
    }
}

Expected output:
WRONG: 'The design is technically perfect.'
But: team boundaries do not match service boundaries
But: the tax is not justified for the workload
But: a new hire cannot debug 8 services under pressure

CORRECT: evaluate technical correctness
AND organizational sustainability

package com.bank.architecture;

public class SeniorKnowledge {
    public static void main(String[] args) {
        System.out.println("1. Hold both verdicts: well designed AND too costly");
        System.out.println("2. Design for debuggability by a stranger at 3 AM");
        System.out.println("3. Design for reversibility: can services merge back?");
        System.out.println("4. Often recommend the modular monolith");
    }
}

Expected output:
1. Hold both verdicts: well designed AND too costly
2. Design for debuggability by a stranger at 3 AM
3. Design for reversibility: can services merge back?
4. Often recommend the modular monolith