Technical Architect Expectations

1// Architect-level thinking: Designing an enterprise integration layer
2// This shows the KIND of code an architect designs (but delegates implementation)
3
4// 1. Enterprise Integration Service — Architect designs the pattern
5public class IntegrationOrchestrator {
6    
7    // Strategy pattern for different integration types
8    private static Map<String, IntegrationStrategy> strategies = 
9        new Map<String, IntegrationStrategy>{
10            'REST' => new RestIntegrationStrategy(),
11            'SOAP' => new SoapIntegrationStrategy(),
12            'PLATFORM_EVENT' => new PlatformEventStrategy()
13        };
14    
15    // Architect designs the contract
16    public interface IntegrationStrategy {
17        IntegrationResult execute(IntegrationRequest request);
18        Boolean supportsRetry();
19        Integer getMaxRetries();
20    }
21    
22    // Orchestration with retry, circuit breaker, and logging
23    public static IntegrationResult process(IntegrationRequest request) {
24        IntegrationStrategy strategy = strategies.get(request.integrationType);
25        
26        if (strategy == null) {
27            throw new IntegrationException(
28                'Unknown integration type: ' + request.integrationType
29            );
30        }
31        
32        IntegrationResult result;
33        Integer attempts = 0;
34        Integer maxRetries = strategy.supportsRetry() ? strategy.getMaxRetries() : 0;
35        
36        while (attempts <= maxRetries) {
37            try {
38                result = strategy.execute(request);
39                logIntegration(request, result, attempts);
40                return result;
41            } catch (CalloutException e) {
42                attempts++;
43                if (attempts > maxRetries) {
44                    result = new IntegrationResult(false, e.getMessage());
45                    logIntegration(request, result, attempts);
46                    // Queue for async retry via Platform Event
47                    publishRetryEvent(request);
48                }
49            }
50        }
51        return result;
52    }
53    
54    private static void logIntegration(
55        IntegrationRequest req, IntegrationResult res, Integer attempts
56    ) {
57        Integration_Log__c log = new Integration_Log__c(
58            Endpoint__c = req.endpoint,
59            Request_Body__c = req.body?.left(131072), // Field limit
60            Response_Body__c = res.responseBody?.left(131072),
61            Status__c = res.success ? 'Success' : 'Failed',
62            Attempts__c = attempts,
63            Timestamp__c = Datetime.now()
64        );
65        insert log; // In production, use async logging
66    }
67    
68    private static void publishRetryEvent(IntegrationRequest request) {
69        Integration_Retry__e event = new Integration_Retry__e(
70            Payload__c = JSON.serialize(request),
71            Retry_Count__c = 0
72        );
73        EventBus.publish(event);
74    }
75}
76
77// The architect doesn't just write code — they design:
78// - Error handling strategy (retry, dead letter queue, alerting)
79// - Monitoring (custom object for logs, dashboard for failures)
80// - Security (named credentials, certificate management)
81// - Scalability (async processing, platform events for decoupling)
82// - Compliance (PII masking in logs, encryption in transit)