What is the difference between availability and reliability, and why must SLIs measure correctness?

package com.bank.observability;

public class AvailabilityVsReliability {
    public static void main(String[] args) {
        System.out.println("Availability: Did the system respond? (reachability)");
        System.out.println("  Measured by: HTTP status codes, latency");
        System.out.println();
        System.out.println("Reliability: Was the response correct? (correctness)");
        System.out.println("  Measured by: actual business outcomes, reconciliation");
        System.out.println();
        System.out.println("These are INDEPENDENT. A system can be:");
        System.out.println("  Available + Reliable: responds AND correct ← GOAL");
        System.out.println("  Available + Unreliable: responds but WRONG ← DANGEROUS");
        System.out.println("  Unavailable + Reliable: down, but when up it's correct");
    }
}

package com.bank.observability;

import java.math.BigDecimal;

public class SilentCorruption {
    public static void main(String[] args) {
        int totalTransfers = 10000;
        int httpSuccess = 9999;
        int actuallySettledCorrectly = 9500;

        double availability = (double) httpSuccess / totalTransfers * 100;
        double reliability = (double) actuallySettledCorrectly / totalTransfers * 100;

        System.out.printf("Availability (HTTP 200 rate): %.2f%%%n", availability);
        System.out.printf("Reliability (actually settled correctly): %.2f%%%n", reliability);
        System.out.println();
        System.out.println("500 transfers returned 200 but money did not move correctly");
        System.out.println("Dashboard: green. Reality: disaster.");
    }
}

Availability (HTTP 200 rate): 99.99%
Reliability (actually settled correctly): 95.00%

500 transfers returned 200 but money did not move correctly
Dashboard: green. Reality: disaster.

package com.bank.observability;

public class SilentVsVisible {
    public static void main(String[] args) {
        System.out.println("Outage (visible failure):");
        System.out.println("  - Detected immediately by monitoring");
        System.out.println("  - Fix the bug → system recovers");
        System.out.println("  - No wrong state to clean up");
        System.out.println();
        System.out.println("Silent incorrectness:");
        System.out.println("  - NOT detected by availability monitoring");
        System.out.println("  - Accumulates for days or weeks");
        System.out.println("  - Discovered by customer complaints or auditors");
        System.out.println("  - Requires manual reconciliation of thousands of accounts");
        System.out.println("  - Possible regulatory consequences");
    }
}

package com.bank.observability;

public class CorrectnessSli {
    public static void main(String[] args) {
        // BAD SLI: just HTTP status
        int httpSuccess = 9999;
        int httpTotal = 10000;
        System.out.printf("Availability SLI: %.2f%% (BLIND to correctness)%n",
                (double) httpSuccess / httpTotal * 100);

        // GOOD SLI: reconciliation-based
        long initiated = 10000;
        long settledCorrectly = 9500;
        System.out.printf("Reliability SLI: %.2f%% (measures actual outcomes)%n",
                (double) settledCorrectly / initiated * 100);

        System.out.println();
        System.out.println("The reliability SLI catches the 500 silent failures");
        System.out.println("that the availability SLI misses entirely.");
    }
}

Availability SLI: 99.99% (BLIND to correctness)
Reliability SLI: 95.00% (measures actual outcomes)

The reliability SLI catches the 500 silent failures
that the availability SLI misses entirely.

package com.bank.observability;

public class ReliabilityDominates {
    public static void main(String[] args) {
        System.out.println("Scenario A: Transfer fails with HTTP 500 (visible error)");
        System.out.println("  Customer retries. Money is correct. Routine.");
        System.out.println();
        System.out.println("Scenario B: Transfer returns HTTP 200 but wrong amount posted");
        System.out.println("  Customer's balance is wrong. Trust destroyed.");
        System.out.println("  Regulatory investigation. Manual remediation.");
        System.out.println();
        System.out.println("For a bank, Scenario B is FAR worse than Scenario A.");
        System.out.println("Reliability > Availability.");
    }
}

Scenario A: Transfer fails with HTTP 500 (visible error)
  Customer retries. Money is correct. Routine.

Scenario B: Transfer returns HTTP 200 but wrong amount posted
  Customer's balance is wrong. Trust destroyed.
  Regulatory investigation. Manual remediation.

For a bank, Scenario B is FAR worse than Scenario A.
Reliability > Availability.

package com.bank.observability;

public class ReliabilityPatterns {
    public static void main(String[] args) {
        System.out.println("Patterns that protect reliability:");
        System.out.println("  1. Idempotency keys → exactly-once semantics");
        System.out.println("  2. Transactional outbox → atomic write + event publish");
        System.out.println("  3. Reconciliation jobs → detect intended vs actual mismatch");
        System.out.println("  4. Synthetic transactions → end-to-end verification");
        System.out.println("  5. Alert on correctness SLI, not just error rate");
    }
}

package com.bank.observability;

// WRONG: catch all exceptions, return 200
// "Our error rate is 0%!" → actually, errors are hidden, state is wrong

// CORRECT: fail honestly with 500, measure correctness via reconciliation
// Error rate is higher, but every success is REAL