Contrarian View: FAANG Experience with Java 23 and C# 13 Matters Less Than Startup Experience in 2026

// Java 23 Startup Inventory Service: Uses Scoped Values for request context, no over-engineering
import java.util.concurrent.*;
import java.util.*;
import java.lang.ScopedValue;

public class StartupInventoryService {
    // Scoped Value for request-specific tenant ID (common in B2B startups)
    private static final ScopedValue<String> TENANT_ID = ScopedValue.newInstance();
    // In-memory inventory store (startups rarely use distributed caches early on)
    private final Map<String, Integer> inventoryStore = new ConcurrentHashMap<>();

    public StartupInventoryService() {
        // Seed initial inventory (startup MVP often hardcodes initial data)
        inventoryStore.put("SKU-123", 150);
        inventoryStore.put("SKU-456", 89);
        inventoryStore.put("SKU-789", 42);
    }

    // Update inventory with tenant-scoped context, no external framework dependencies
    public void updateInventory(String sku, int delta, String tenantId) throws InventoryUpdateException {
        if (delta == 0) {
            throw new IllegalArgumentException("Delta cannot be zero");
        }
        // Run with scoped tenant ID to avoid passing context through all method calls
        ScopedValue.where(TENANT_ID, tenantId).run(() -> {
            try {
                int current = inventoryStore.getOrDefault(sku, 0);
                int updated = current + delta;
                if (updated < 0) {
                    throw new InventoryUpdateException("Insufficient inventory for SKU " + sku + 
                        " in tenant " + TENANT_ID.get() + ". Current: " + current + ", Delta: " + delta);
                }
                inventoryStore.put(sku, updated);
                // Log without external logging framework (startups use System.out initially)
                System.out.printf("[Tenant: %s] Updated SKU %s: %d -> %d%n", 
                    TENANT_ID.get(), sku, current, updated);
            } catch (InventoryUpdateException e) {
                // Wrap and rethrow to preserve context
                throw new RuntimeException("Inventory update failed for tenant " + TENANT_ID.get(), e);
            }
        });
    }

    // Get current inventory for a tenant, uses pattern matching for switch (Java 23 final feature)
    public String getInventoryReport(String tenantId) {
        return ScopedValue.where(TENANT_ID, tenantId).call(() -> {
            List<String> reportLines = new ArrayList<>();
            reportLines.add("Inventory Report for Tenant: " + TENANT_ID.get());
            reportLines.add("----------------------------------------");
            inventoryStore.forEach((sku, qty) -> {
                // Pattern matching for switch to format status (Java 23 feature)
                String status = switch (qty) {
                    case int i when i > 100 -> "HIGH";
                    case int i when i > 50 -> "MEDIUM";
                    case int i when i > 0 -> "LOW";
                    default -> "OUT_OF_STOCK";
                };
                reportLines.add(String.format("SKU: %s | Qty: %d | Status: %s", sku, qty, status));
            });
            return String.join("
", reportLines);
        });
    }

    // Custom exception with error context
    public static class InventoryUpdateException extends Exception {
        public InventoryUpdateException(String message) {
            super(message);
        }
        public InventoryUpdateException(String message, Throwable cause) {
            super(message, cause);
        }
    }

    // Main method for quick startup validation (no TestNG/JUnit dependency initially)
    public static void main(String[] args) {
        StartupInventoryService service = new StartupInventoryService();
        try {
            service.updateInventory("SKU-123", -20, "tenant_abc");
            service.updateInventory("SKU-456", 30, "tenant_abc");
            System.out.println(service.getInventoryReport("tenant_abc"));
            // Try invalid update
            service.updateInventory("SKU-123", -200, "tenant_abc");
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

// C# 13 Startup Payment Processor: Uses params collections and new lock type, minimal dependencies
using System;
using System.Collections.Generic;
using System.Threading;

public class StartupPaymentProcessor {
    // C# 13 params collections: accept any IEnumerable<string> for payment methods
    public required params string[] SupportedPaymentMethods { get; init; }
    // In-memory transaction store (startups avoid distributed ledgers initially)
    private readonly Dictionary<string, Transaction> _transactions = new();
    // C# 13 new System.Threading.Lock type (replaces lock keyword)
    private readonly Lock _transactionLock = new();

    public StartupPaymentProcessor() {
        // Default supported methods for MVP
        SupportedPaymentMethods = ["credit_card", "ach", "crypto"];
    }

    // Process payment with params collections for metadata (C# 13 feature)
    public TransactionResult ProcessPayment(string userId, decimal amount, params string[] metadata) {
        if (amount <= 0) {
            throw new ArgumentOutOfRangeException(nameof(amount), "Amount must be positive");
        }
        if (string.IsNullOrEmpty(userId)) {
            throw new ArgumentException("User ID cannot be null or empty", nameof(userId));
        }

        var transactionId = Guid.NewGuid().ToString();
        var transaction = new Transaction {
            Id = transactionId,
            UserId = userId,
            Amount = amount,
            Metadata = new List<string>(metadata),
            Timestamp = DateTimeOffset.UtcNow,
            Status = TransactionStatus.Pending
        };

        // Use C# 13 Lock type instead of lock keyword
        lock (_transactionLock) {
            if (_transactions.ContainsKey(transactionId)) {
                return new TransactionResult {
                    Success = false,
                    ErrorMessage = "Duplicate transaction ID",
                    TransactionId = transactionId
                };
            }
            _transactions[transactionId] = transaction;
        }

        try {
            // Simulate payment gateway call (startups use direct HTTP calls initially)
            bool gatewaySuccess = SimulateGatewayCall(amount, userId);
            transaction.Status = gatewaySuccess ? TransactionStatus.Completed : TransactionStatus.Failed;

            return new TransactionResult {
                Success = gatewaySuccess,
                TransactionId = transactionId,
                ErrorMessage = gatewaySuccess ? null : "Payment gateway rejected transaction"
            };
        } catch (Exception ex) {
            transaction.Status = TransactionStatus.Failed;
            // Log to console (no external logging framework)
            Console.WriteLine($"[ERROR] Payment failed for {transactionId}: {ex.Message}");
            return new TransactionResult {
                Success = false,
                TransactionId = transactionId,
                ErrorMessage = $"Payment processing failed: {ex.Message}"
            };
        }
    }

    // Get transaction report with pattern matching (C# 13 enhancements)
    public string GetTransactionReport() {
        lock (_transactionLock) {
            var reportLines = new List<string> {
                "Payment Transaction Report",
                "--------------------------"
            };
            foreach (var tx in _transactions.Values) {
                string statusLine = tx.Status switch {
                    TransactionStatus.Completed => $"✅ Completed: {tx.Amount:C} for {tx.UserId}",
                    TransactionStatus.Pending => $"⏳ Pending: {tx.Amount:C} for {tx.UserId}",
                    TransactionStatus.Failed => $"❌ Failed: {tx.Amount:C} for {tx.UserId}",
                    _ => $"Unknown status: {tx.Status}"
                };
                reportLines.Add($"ID: {tx.Id} | {statusLine}");
            }
            return string.Join("
", reportLines);
        }
    }

    private bool SimulateGatewayCall(decimal amount, string userId) {
        // Simulate 95% success rate for MVP
        return new Random().NextDouble() < 0.95;
    }

    // Nested classes for transaction data (no external DTO libraries)
    public class Transaction {
        public required string Id { get; set; }
        public required string UserId { get; set; }
        public required decimal Amount { get; set; }
        public required List<string> Metadata { get; set; }
        public required DateTimeOffset Timestamp { get; set; }
        public required TransactionStatus Status { get; set; }
    }

    public enum TransactionStatus {
        Pending,
        Completed,
        Failed
    }

    public class TransactionResult {
        public required bool Success { get; set; }
        public string? ErrorMessage { get; set; }
        public required string TransactionId { get; set; }
    }

    // Main method for quick validation
    public static void Main() {
        var processor = new StartupPaymentProcessor();
        try {
            var result1 = processor.ProcessPayment("user_123", 49.99m, "source:mobile", "campaign:spring_sale");
            Console.WriteLine($"Payment 1: {result1.Success} | ID: {result1.TransactionId}");
            var result2 = processor.ProcessPayment("user_456", -10m); // Should fail
        } catch (Exception ex) {
            Console.WriteLine($"Error: {ex.Message}");
        }
        Console.WriteLine(processor.GetTransactionReport());
    }
}

// Vertical slice handler: no shared services, single file for order creation
public class CreateOrderHandler {
    private final DataSource ds;
    public CreateOrderHandler(DataSource ds) { this.ds = ds; }
    public Order createOrder(CreateOrderRequest req) throws SQLException {
        try (Connection conn = ds.getConnection()) {
            // Insert order and items in single transaction
            PreparedStatement ps = conn.prepareStatement("INSERT INTO orders (user_id, total) VALUES (?, ?) RETURNING id");
            ps.setString(1, req.userId());
            ps.setBigDecimal(2, req.total());
            ResultSet rs = ps.executeQuery();
            rs.next();
            String orderId = rs.getString("id");
            // Insert items
            PreparedStatement itemPs = conn.prepareStatement("INSERT INTO order_items (order_id, sku, qty) VALUES (?, ?, ?)");
            for (OrderItem item : req.items()) {
                itemPs.setString(1, orderId);
                itemPs.setString(2, item.sku());
                itemPs.setInt(3, item.qty());
                itemPs.addBatch();
            }
            itemPs.executeBatch();
            return new Order(orderId, req.userId(), req.total(), "CREATED");
        }
    }
}

// Export basic JVM metrics to Prometheus (no external libraries)
import java.lang.management.ManagementFactory;
import java.util.concurrent.atomic.AtomicLong;

public class PrometheusMetrics {
    private static final AtomicLong REQUEST_COUNT = new AtomicLong(0);
    private static final AtomicLong ERROR_COUNT = new AtomicLong(0);

    public static void incrementRequest() { REQUEST_COUNT.incrementAndGet(); }
    public static void incrementError() { ERROR_COUNT.incrementAndGet(); }

    public static String getMetrics() {
        var mem = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
        return String.format("""
            # HELP http_requests_total Total HTTP requests
            # TYPE http_requests_total counter
            http_requests_total %d
            # HELP http_errors_total Total HTTP errors
            # TYPE http_errors_total counter
            http_errors_total %d
            # HELP jvm_heap_used_bytes JVM heap used bytes
            # TYPE jvm_heap_used_bytes gauge
            jvm_heap_used_bytes %d
            """, REQUEST_COUNT.get(), ERROR_COUNT.get(), mem.getUsed());
    }
}

// Small fix: add null check to StringUtils.trimToNull (Java 23)
public class StringUtils {
    // Original method: throws NPE if input is null
    public static String trimToNull(String input) {
        if (input == null) return null; // Added null check (contribution)
        String trimmed = input.trim();
        return trimmed.isEmpty() ? null : trimmed;
    }
    // Test case for contribution
    public static void main(String[] args) {
        assert trimToNull(null) == null : "Null input should return null";
        assert trimToNull("  ") == null : "Whitespace only should return null";
        assert "test".equals(trimToNull(" test ")) : "Trimmed string should return test";
        System.out.println("All tests passed");
    }
}