What a shadow deployment is and how to implement it

package com.bank.shadow;

import java.math.BigDecimal;
import java.util.logging.Logger;

public class ShadowServiceConfig {

    private static final Logger LOG = Logger.getLogger(ShadowServiceConfig.class.getName());

    // WRONG: Shadow shares live database and payment rail.
    public void wrongShadow(String paymentId, BigDecimal amount) {
        // liveDatabase.save(payment);  <- double-writes records
        // paymentRail.send(amount);    <- moves real money twice
        LOG.severe("Shadow caused real side effects.");
    }

    // CORRECT: Shadow uses isolated datastore and mocked externals.
    public void correctShadow(String paymentId, BigDecimal amount) {
        // shadowDatabase.save(payment);  <- isolated, no real impact
        // noopPaymentRail.send(amount);  <- no-op, money never moves
        LOG.info("Shadow processed safely in isolation.");
    }
}

Isolation requirements for banking:
- Separate database or read-only connection
- Payment rail: no-op or sandbox mode
- Notifications: disabled (no SMS, no email)
- Kafka: separate topic or no-op producer
- Compliance: same encryption and access controls as production

package com.bank.shadow;

import java.util.logging.Logger;

public class ResponseComparator {

    private static final Logger LOG = Logger.getLogger(ResponseComparator.class.getName());

    public void compare(String requestId, String liveResponse, String shadowResponse,
                        long liveLatencyMs, long shadowLatencyMs) {
        if (!liveResponse.equals(shadowResponse)) {
            LOG.warning("MISMATCH requestId=" + requestId
                + " live=" + liveResponse
                + " shadow=" + shadowResponse);
        }
        if (shadowLatencyMs > liveLatencyMs * 2) {
            LOG.warning("SLOW SHADOW requestId=" + requestId
                + " liveMs=" + liveLatencyMs
                + " shadowMs=" + shadowLatencyMs);
        }
    }
}

Expected comparison output:
MATCH:    requestId=R001 live={balance:50000} shadow={balance:50000}
MISMATCH: requestId=R002 live={balance:0} shadow={balance:1.00}
  -> Edge case bug: zero-principal account returns 1 rupee in shadow.
  -> Customer got correct live answer (zero impact).
  -> Bug found before promotion.

# Istio VirtualService with traffic mirroring
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: interest-calculation
spec:
  hosts:
    - interest-service
  http:
    - route:
        - destination:
            host: interest-service
            subset: stable  # live version
      mirror:
        host: interest-service
        subset: shadow  # new version
      mirrorPercentage:
        value: 10.0  # mirror 10% of traffic

Expected behavior:
100% of traffic served by stable (live responses to clients)
10% of traffic copied to shadow (responses discarded)
Shadow environment has isolated DB and no-op externals.

package com.bank.gateway.filter;

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class ShadowMirrorFilter implements GatewayFilter {

    private final WebClient shadowClient;

    public ShadowMirrorFilter(WebClient.Builder builder) {
        this.shadowClient = builder.baseUrl("http://shadow-interest-service").build();
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Fire-and-forget: never delay the real response
        shadowClient.method(exchange.getRequest().getMethod())
            .uri(exchange.getRequest().getURI().getPath())
            .exchange()
            .subscribe(); // result discarded

        return chain.filter(exchange); // real response proceeds normally
    }
}

Key: fire-and-forget. A slow shadow NEVER delays the real response.

package com.bank.antipattern;

// WRONG: Shadow shares live database.
public class WrongShadow {
    // Mirrored transfer writes to live payments table -> double records
    // Mirrored notification sends real SMS -> customer confused
}

// CORRECT: Shadow uses isolated DB and no-op externals.
public class CorrectShadow {
    // shadowPaymentsDb -> isolated, periodically wiped
    // noOpNotifier -> logs but does not send
    // noOpPaymentRail -> no money moves
}