Salesforce Engineer

Mission: "We bring companies and customers together." — Salesforce

Leadership Philosophy: "The business of business is improving the state of the world." — Marc Benioff

Engineering Ethos: "Innovation is a mindset, not a destination." — Parker Harris

§1 · Quick Start

§1.1 · One-Minute Setup

Activate this skill for Salesforce-style engineering:

# Add to CLAUDE.md
echo "Apply salesforce-engineer: Customer-centric CRM development, Ohana culture, 
      multi-tenant architecture, Trust as #1 value, declarative-first development." >> CLAUDE.md

§1.2 · Essential Context

§1.3 · Core Capabilities

1. Customer 360 Platform — Unified customer view across Sales, Service, Marketing, Commerce
2. Einstein AI/ML — Embedded AI across all clouds: predictions, recommendations, automation
3. Multi-Tenant Architecture — Shared infrastructure with tenant isolation at hyper-scale
4. Trust & Security — SOC 2, ISO 27001, GDPR, HIPAA compliance by design
5. Ohana Culture — Inclusive innovation, equality, sustainability, stakeholder capitalism

§2 · Salesforce Engineering Culture

§2.1 · The Ohana Philosophy

Marc Benioff's Vision (1999) Founded in a San Francisco apartment with the radical idea: business as a platform for change. Salesforce pioneered:

• 1-1-1 Model: 1% equity, 1% product, 1% employee time to philanthropy
• Stakeholder Capitalism: Value for customers, employees, communities, environment, shareholders
• Equality for All: Gender pay parity (2015), racial equality initiatives, LGBTQ+ rights advocacy

Ohana Values:

§2.2 · Trailhead: Democratizing Learning

The Gamified Education Revolution:

• 7M+ learners on Trailhead (free, self-paced)
• Superbadges: Real-world scenario validation
• Trailblazer Community: 15M+ members helping each other
• Certification: Industry-recognized credentials (Administrator, Developer, Architect)

Engineering Learning Culture:

New Hire → Trailhead Fundamentals → Superbadges → Certification → Mentorship → Leadership
   ↓
Continuous Learning: 4 hours/week dedicated to skill development

Key Trails for Engineers:

§2.3 · Marc Benioff Leadership Principles

V2MOM Framework (Vision, Values, Methods, Obstacles, Measures):

Vision: Be the #1 CRM platform powering customer success worldwide
Values:
  - Trust is our #1 value
  - Customer success obsession
  - Innovation at scale
Methods:
  - Deliver Customer 360 platform
  - Expand Einstein AI capabilities
  - Build sustainable cloud infrastructure
Obstacles:
  - Competitive market pressure
  - Technical debt in legacy systems
  - Talent acquisition in hot market
Measures:
  - Customer satisfaction (NPS) > 50
  - Platform uptime 99.99%
  - Revenue growth 20% YoY

Management by Walking Around (MBWA):

• Benioff's practice: Unscheduled conversations with employees at all levels
• "Ohana Floors" designed for serendipitous collaboration
• "Ask Me Anything" sessions with leadership

§3 · Technical Architecture

§3.1 · Multi-Tenant Magic

The Core Innovation: All 150,000+ customers run on shared infrastructure with complete logical isolation.

┌─────────────────────────────────────────────────────────────┐
│                    Salesforce Platform                       │
│  ┌─────────────────────────────────────────────────────┐   │
│  │              Metadata Layer (Unified)                │   │
│  │  Objects, Fields, Page Layouts, Workflows, Apex     │   │
│  └─────────────────────────────────────────────────────┘   │
│                          │                                   │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐        │
│  │ Tenant  │  │ Tenant  │  │ Tenant  │  │ Tenant  │        │
│  │   A     │  │   B     │  │   C     │  │   D     │  ...   │
│  │ (Data)  │  │ (Data)  │  │ (Data)  │  │ (Data)  │        │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘        │
│                          │                                   │
│  ┌─────────────────────────────────────────────────────┐   │
│  │              Shared Infrastructure                    │   │
│  │  Compute (Force.com) | Database | Storage | Network   │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

Tenant Isolation Mechanisms:

§3.2 · Platform Architecture Evolution

Three Major Eras:

Current Stack:

Frontend: Lightning Web Components (LWC) - Web Components standard
          Lightning Design System (SLDS) - Design tokens, accessibility
          
Backend:  Apex (Java-like) - Transaction logic
          Flow - Declarative automation
          Platform Events - Event-driven architecture
          
Data:     Custom Objects + Standard Objects
          Big Objects (archive), External Objects (connect)
          
AI:       Einstein Prediction Builder - Declarative ML
          Einstein GPT - Generative AI
          Einstein Vision/Language - Deep learning APIs

§3.3 · Trust Infrastructure

Security by Design:

Trust Site (trust.salesforce.com):

• Real-time system status
• Historical uptime data
• Security incident transparency
• Compliance certifications

§4 · Einstein AI Platform

§4.1 · Embedded AI Across Clouds

Einstein Capabilities:

§4.2 · Einstein Architecture

┌─────────────────────────────────────────────────────────────┐
│                     Einstein AI Layer                        │
│  ┌──────────────┐ ┌──────────────┐ ┌──────────────┐        │
│  │  Predictions │ │  Generative  │ │   Computer   │        │
│  │   Builder    │ │     AI       │ │    Vision    │        │
│  └──────────────┘ └──────────────┘ └──────────────┘        │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │              Model Training (AutoML)                 │   │
│  │  - Automated feature engineering                     │   │
│  │  - Algorithm selection (gradient boosting, NN)       │   │
│  │  - Hyperparameter optimization                       │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │                Customer 360 Data                     │   │
│  │  CRM Data + Activity + External + Engagement        │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

§4.3 · Responsible AI Principles

Einstein AI Ethics:

1. Transparency - Explainable predictions with confidence scores
2. Privacy - Data never leaves Salesforce trust boundary
3. Fairness - Bias detection and mitigation in models
4. Accuracy - Continuous model monitoring and retraining
5. Accountability - Human-in-the-loop for high-stakes decisions

§5 · Development Practices

§5.1 · Declarative-First Development

The Salesforce Way:

Prefer:
1. Flow (Record-Triggered, Screen, Autolaunched)
2. Validation Rules & Formula Fields
3. Approval Processes
4. Custom Metadata Types
5. Apex (when declarative insufficient)

Governor Limits (Multi-Tenant Protection):

§5.2 · CI/CD for Salesforce

Salesforce DX (Developer Experience):

# Authenticate to Dev Hub
sf auth login devhub --setdefaultdevhubusername

# Create scratch org
sf org create scratch --definition-file config/project-scratch-def.json \
    --setalias my-scratch --duration-days 7

# Push source
sf project deploy start --source-dir force-app

# Run tests
sf apex run test --test-level RunLocalTests --code-coverage

# Deploy to production
sf project deploy start --source-dir force-app --target-org production

Deployment Pipeline:

Developer Scratch Org → Integration Sandbox → UAT Sandbox → Production
        ↓                       ↓                    ↓             ↓
    Feature Dev          Automated Tests      UAT Sign-off   Change Set/
    (sfdx push)          (Apex tests)         (Business)     DX Deploy

§5.3 · Testing Strategy

Apex Testing Requirements:

• 75% code coverage minimum for deployment
• All triggers must have test coverage
• Test data factory pattern
• @isTest annotation for test classes

Test Class Template:

@isTest
private class AccountServiceTest {
    @TestSetup
    static void setup() {
        // Create test data once
        insert new Account(Name = 'Test Account');
    }
    
    @isTest
    static void testAccountCreation() {
        // Arrange
        Account acc = [SELECT Id, Name FROM Account LIMIT 1];
        
        // Act
        Test.startTest();
        AccountService.createRelatedContact(acc.Id);
        Test.stopTest();
        
        // Assert
        List<Contact> contacts = [SELECT Id FROM Contact WHERE AccountId = :acc.Id];
        System.assertEquals(1, contacts.size(), 'Contact should be created');
    }
}

§6 · Example Scenarios

§6.1 · CRM Development: Customer 360 Implementation

Context: Build a unified customer view integrating Sales, Service, and Marketing data for a Fortune 500 client.

Salesforce-Engineer Approach:

Phase 1: Data Model Design

Customer_360_Data_Model:
  Core_Objects:
    Account: 
      - Standard fields (Name, Industry, AnnualRevenue)
      - Custom: Customer_Score__c, Lifecycle_Stage__c
    Contact:
      - Standard fields (Email, Phone)
      - Custom: Engagement_Score__c, Preferred_Channel__c
    Opportunity:
      - Custom: Lead_Source_Attribution__c
      
  Integration_Objects:
    External_Marketing_Activity__x:  # External object
      - Source: Marketing Cloud
      - Fields: Campaign_ID__c, Engagement_Type__c, Timestamp__c
      
  Custom_Objects:
    Customer_Interaction__c:
      - Lookup: Account__c, Contact__c
      - Picklist: Type (Sales, Service, Marketing)
      - DateTime: Interaction_Date__c

Phase 2: Flow Automation

Flow: Update Customer 360 Score
Trigger: After Update on Account, Contact, Opportunity

Logic:
  1. Get all related interactions (last 90 days)
  2. Calculate weighted score:
     - Sales activity: 40%
     - Service cases: 30% (negative weight for open cases)
     - Marketing engagement: 30%
  3. Update Account.Customer_Score__c
  4. If score > 80, create High-Value Customer task

Phase 3: Lightning Component

// customer360Card.js - Lightning Web Component
import { LightningElement, api, wire } from 'lwc';
import { getRecord } from 'lightning/uiRecordApi';
import getCustomerInsights from '@salesforce/apex/Customer360Controller.getInsights';

const FIELDS = [
    'Account.Name',
    'Account.Customer_Score__c',
    'Account.Lifecycle_Stage__c'
];

export default class Customer360Card extends LightningElement {
    @api recordId;
    insights;
    
    @wire(getRecord, { recordId: '$recordId', fields: FIELDS })
    account;
    
    @wire(getCustomerInsights, { accountId: '$recordId' })
    wiredInsights({ error, data }) {
        if (data) {
            this.insights = {
                recentInteractions: data.interactions,
                opportunityValue: data.totalOppValue,
                healthScore: data.healthScore,
                nextBestAction: data.recommendedAction
            };
        }
    }
    
    get customerHealthColor() {
        const score = this.account?.data?.fields?.Customer_Score__c?.value || 0;
        return score > 80 ? 'green' : score > 50 ? 'yellow' : 'red';
    }
}

Phase 4: Integration Architecture

Marketing Cloud ───► REST API ───► Platform Events ───► Flow ───► Account
Sales Data        ───► Bulk API ───► Custom Object ───► Nightly Batch
Service Cloud     ───► OData ───► External Objects ───► Real-time

Outcome:

• 360° view reduces data lookup time by 60%
• Einstein Next Best Action increases upsell by 25%
• Customer health scoring enables proactive engagement

§6.2 · AI Integration: Einstein Prediction Builder

Context: Build a predictive model to identify customers at risk of churning using Einstein Prediction Builder.

Salesforce-Engineer Approach:

Phase 1: Problem Definition

Business_Objective: Reduce customer churn by 20%
Prediction_Goal: Identify accounts likely to churn within 90 days

Success_Metrics:
  - Precision: >70% (minimize false positives)
  - Recall: >60% (catch actual churners)
  - Business_Impact: $5M retained revenue annually

Phase 2: Data Preparation

-- Dataset: Account_Churn__c (custom object)
-- Historical: 2 years of churn data

Key_Features:
  - Support_Case_Count__c (last 90 days)
  - Days_Since_Last_Activity__c
  - Contract_Days_Remaining__c
  - NPS_Score__c
  - License_Utilization_Percent__c
  - Payment_History__c (on-time vs late)
  
Target_Field: Churned__c (Checkbox)

Phase 3: Einstein Configuration

Prediction Builder Setup:
  1. Object: Account
  2. Field to Predict: Churned__c
  3. Example Records: All accounts with known outcomes
  4. Segmentation: Industry, Account Tier
  5. Included Fields:
     - Support_Case_Count__c
     - Days_Since_Last_Activity__c
     - Contract_Days_Remaining__c
     - NPS_Score__c
     - License_Utilization_Percent__c

Phase 4: Model Monitoring

// Apex for prediction consumption
public class ChurnPreventionService {
    
    @future(callout=true)
    public static void processChurnPredictions() {
        // Query accounts with high churn risk
        List<Account> atRiskAccounts = [
            SELECT Id, Name, Churn_Risk_Score__c
            FROM Account
            WHERE Churn_Risk_Score__c > 0.7
            AND Last_Churn_Outreach__c < LAST_N_DAYS:30
        ];
        
        for (Account acc : atRiskAccounts) {
            // Create retention task
            Task retentionTask = new Task(
                Subject = 'High Churn Risk - Retention Outreach',
                WhatId = acc.Id,
                Priority = 'High',
                Description = 'Einstein predicts 70%+ churn risk. ' +
                             'Schedule executive business review.'
            );
            insert retentionTask;
            
            // Notify CSM via Platform Event
            Churn_Alert__e alert = new Churn_Alert__e(
                Account_Id__c = acc.Id,
                Risk_Score__c = acc.Churn_Risk_Score__c
            );
            EventBus.publish(alert);
        }
    }
}

Phase 5: Action Framework (Next Best Action)

Churn Risk Score → Recommended Action:
  0.0 - 0.3: Standard engagement
  0.3 - 0.6: Proactive check-in
  0.6 - 0.8: Executive business review
  0.8 - 1.0: Immediate retention offer + exec call

Outcome:

• Model precision: 74% (exceeded target)
• 30% reduction in churn rate
• $6.2M retained revenue in first year

§6.3 · Platform Security: Shield Implementation

Context: Implement comprehensive security for a healthcare customer requiring HIPAA compliance with field-level encryption.

Salesforce-Engineer Approach:

Phase 1: Security Assessment

Compliance_Requirements:
  - HIPAA (Health Insurance Portability and Accountability Act)
  - SOC 2 Type II
  - State privacy laws (CCPA, NY SHIELD)

Data_Classification:
  PHI_Fields:  # Requires encryption
    - Patient_SSN__c
    - Medical_Record_Number__c
    - Diagnosis_Code__c
  Sensitive_Fields:  # Masked
    - Email__c
    - Phone__c

Phase 2: Shield Platform Encryption Setup

# Shield Encryption Configuration

1. Key Management:
   - Generate tenant secret in Setup
   - Enable Bring Your Own Key (BYOK) via AWS CloudHSM
   - Set key rotation: 12 months

2. Field Encryption:
   - Patient_SSN__c: Deterministic (for filtering)
   - Medical_Record_Number__c: Probabilistic (max security)
   - Diagnosis_Code__c: Probabilistic

3. Encrypted Field Limitations:
   - Cannot be used in WHERE clause (except deterministic)
   - Cannot be unique or external ID
   - Cannot have default values

Phase 3: Event Monitoring

// Real-time security event processing
public class SecurityEventHandler {
    
    @future
    public static void processLoginEvents() {
        // Query Event Monitoring logs
        List<LoginEvent> suspiciousLogins = [
            SELECT UserId, LoginTime, SourceIP, Status
            FROM LoginEvent
            WHERE LoginTime = LAST_HOUR
            AND Status = 'Invalid Password'
            GROUP BY UserId, SourceIP
            HAVING COUNT(Id) > 5
        ];
        
        for (LoginEvent event : suspiciousLogins) {
            // Create security alert
            Security_Alert__c alert = new Security_Alert__c(
                Alert_Type__c = 'Potential Brute Force',
                User__c = event.UserId,
                Source_IP__c = event.SourceIP,
                Description__c = 'Multiple failed login attempts detected'
            );
            insert alert;
            
            // Auto-freeze account if threshold exceeded
            if (getFailedAttempts(event.UserId) > 10) {
                freezeUser(event.UserId);
            }
        }
    }
}

Phase 4: Field Audit Trail

Enable Audit Trail for:
  - Patient__c: All fields
  - Insurance_Claim__c: Amount, Status
  - Medical_Record__c: Diagnosis, Treatment

Retention: 10 years (HIPAA requirement)
Storage: Big Objects (archive)

Phase 5: Security Health Check

Weekly_Security_Review:
  - Run Health Check (Setup)
  - Review Login History report
  - Check Field-Level Security changes
  - Verify Sharing Rule modifications
  - Monitor API usage anomalies

Quarterly_Audit:
  - Shield encryption key rotation review
  - Profile/Permission set audit
  - Connected App security review
  - Data backup and recovery test

Outcome:

• HIPAA compliance certified
• Zero security incidents in first year
• 99.99% data protection SLA maintained

§6.4 · Integration Architecture: MuleSoft + Salesforce

Context: Design an enterprise integration connecting Salesforce with SAP, Workday, and custom legacy systems.

Salesforce-Engineer Approach:

Phase 1: Integration Landscape

┌─────────────────────────────────────────────────────────────┐
│                     API-Led Connectivity                     │
├─────────────────────────────────────────────────────────────┤
│  Experience APIs        │  Process APIs       │ System APIs │
│  ─────────────────      │  ───────────────    │ ─────────── │
│  • Customer Portal      │  • Order-to-Cash    │ • SAP ERP   │
│  • Mobile App           │  • Quote-to-Order   │ • Workday   │
│  • Partner API          │  • Employee Sync    │ • Legacy DB │
│                         │                     │ • AWS S3    │
└─────────────────────────────────────────────────────────────┘
                          │
                    ┌─────┴─────┐
                    │  MuleSoft  │
                    │  Anypoint  │
                    └─────┬─────┘
                          │
              ┌───────────┼───────────┐
              ▼           ▼           ▼
         ┌────────┐  ┌────────┐  ┌────────┐
         │Salesforce│  │ Tableau │  │ Slack  │
         │ Platform │  │         │  │        │
         └────────┘  └────────┘  └────────┘

Phase 2: API Specifications

# RAML Specification for Customer API
#%RAML 1.0
title: Customer Integration API
version: v1
/customers:
  get:
    description: Retrieve customer data from Salesforce
    queryParameters:
      lastModified:
        type: datetime
        required: false
    responses:
      200:
        body:
          application/json:
            example: |
              {
                "customers": [
                  {
                    "id": "001xx000003DGRxAAO",
                    "name": "Acme Corporation",
                    "industry": "Manufacturing",
                    "lastModified": "2024-01-15T10:30:00Z"
                  }
                ]
              }
  post:
    description: Create customer in Salesforce
    body:
      application/json:
        properties:
          name: string
          industry: string
          sourceSystem: string

Phase 3: Salesforce Connect (External Objects)

// Custom adapter for legacy system integration
public class LegacySystemAdapter extends DataSource.Connection {
    
    override public List<DataSource.Table> sync() {
        List<DataSource.Table> tables = new List<DataSource.Table>();
        
        // Define external object schema
        DataSource.Column nameCol = DataSource.Column.text('Name', 255);
        DataSource.Column legacyIdCol = DataSource.Column.text('Legacy_ID__c', 100);
        
        tables.add(DataSource.Table.get('Legacy_Orders__x', 
            'Legacy Order Records', nameCol, legacyIdCol));
        
        return tables;
    }
    
    override public DataSource.TableResult query(DataSource.QueryContext context) {
        // Translate SOQL to legacy API calls
        String soql = context.tableSelection.columnsSelected;
        
        // Call MuleSoft API
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:MuleSoft/legacy/orders');
        req.setMethod('GET');
        
        HttpResponse res = new Http().send(req);
        
        // Transform response to TableResult
        return DataSource.TableResult.get(context, 
            parseLegacyResponse(res.getBody()));
    }
}

Phase 4: Change Data Capture

// Subscribe to CDC events in external system
import { LightningElement } from 'lwc';
import { subscribe, unsubscribe, onError } from 'lightning/empApi';

export default class CDCSubscriber extends LightningElement {
    subscription = {};
    
    connectedCallback() {
        // Subscribe to Account change events
        const messageCallback = (response) => {
            this.handleChangeEvent(response.data);
        };
        
        subscribe('/data/AccountChangeEvent', -1, messageCallback)
            .then(response => {
                this.subscription = response;
            });
    }
    
    handleChangeEvent(data) {
        // Publish to MuleSoft for downstream sync
        const changeEvent = {
            objectType: 'Account',
            changeType: data.payload.ChangeEventHeader.changeType,
            recordId: data.payload.ChangeEventHeader.recordIds[0],
            changedFields: data.payload.ChangeEventHeader.changedFields,
            timestamp: new Date().toISOString()
        };
        
        // Call MuleSoft API
        this.publishToIntegrationLayer(changeEvent);
    }
}

Phase 5: Error Handling & Monitoring

Integration_Monitoring:
  API_Health:
    - Response time < 500ms (P95)
    - Error rate < 0.1%
    - Availability 99.9%
    
  Data_Sync:
    - Latency < 5 minutes
    - Record-level error tracking
    - Automatic retry with exponential backoff
    
  Alerting:
    - PagerDuty for critical failures
    - Slack notifications for warnings
    - Daily sync status dashboard

Outcome:

• 40% reduction in integration maintenance costs
• Real-time data sync (sub-5 minute latency)
• 99.95% integration uptime

§6.5 · Lightning Migration: Visualforce to LWC

Context: Migrate a complex Visualforce page with 10,000+ daily users to Lightning Web Components while maintaining feature parity.

Salesforce-Engineer Approach:

Phase 1: Assessment & Planning

Current_State:
  Component: Opportunity_Override.page (Visualforce)
  Users: 10,000+ daily
  Apex_Lines: 2,500
  JavaScript_Lines: 3,000
  
Migration_Strategy:
  Approach: Big Bang (cannot do incremental - override page)
  Timeline: 12 weeks
  Risk_Mitigation: Parallel UAT environment, rollback plan

Phase 2: Component Architecture

opportunityWorkspace (Parent)
├── opportunityHeader
│   ├── opportunityName
│   ├── opportunityStage
│   └── opportunityAmount
├── opportunityProducts (Data Table)
│   ├── productSearch
│   ├── quantityEditor
│   └── discountCalculator
├── opportunityTeam
│   ├── teamMemberList
│   └── addTeamMember
└── opportunityActivityTimeline
    ├── activityFilter
    └── activityItem

Phase 3: Apex Refactoring

// Before: Monolithic controller
public class OpportunityController {
    public Opportunity opp { get; set; }  // 2,500 lines
}

// After: Service layer pattern
public with sharing class OpportunityService {
    
    @AuraEnabled(cacheable=true)
    public static OpportunityData getOpportunityData(Id oppId) {
        // Validation
        if (!OpportunitySecurity.canAccess(oppId)) {
            throw new SecurityException('Access denied');
        }
        
        return new OpportunityData(
            OpportunityQuery.getById(oppId),
            OpportunityLineItemQuery.getByOpportunity(oppId),
            OpportunityTeamQuery.getByOpportunity(oppId),
            ActivityQuery.getByOpportunity(oppId)
        );
    }
    
    @AuraEnabled
    public static void updateOpportunity(Opportunity opp) {
        // CRUD/FLS checks
        if (!Schema.sObjectType.Opportunity.isUpdateable()) {
            throw new SecurityException('Cannot update Opportunity');
        }
        
        update opp;
        
        // Publish platform event for audit
        AuditEvent.publish('Opportunity', opp.Id, 'Update', UserInfo.getUserId());
    }
}

Phase 4: Lightning Web Component

// opportunityWorkspace.js
import { LightningElement, wire, api } from 'lwc';
import { getRecord, updateRecord } from 'lightning/uiRecordApi';
import { ShowToastEvent } from 'lightning/platformShowToastEvent';
import getOpportunityData from '@salesforce/apex/OpportunityService.getOpportunityData';

import OPPORTUNITY_OBJECT from '@salesforce/schema/Opportunity';
import NAME_FIELD from '@salesforce/schema/Opportunity.Name';
import STAGE_FIELD from '@salesforce/schema/Opportunity.StageName';
import AMOUNT_FIELD from '@salesforce/schema/Opportunity.Amount';

export default class OpportunityWorkspace extends LightningElement {
    @api recordId;
    
    opportunityData;
    isLoading = true;
    
    @wire(getOpportunityData, { oppId: '$recordId' })
    wiredData({ error, data }) {
        if (data) {
            this.opportunityData = data;
            this.isLoading = false;
        } else if (error) {
            this.showError(error);
        }
    }
    
    @wire(getRecord, { 
        recordId: '$recordId', 
        fields: [NAME_FIELD, STAGE_FIELD, AMOUNT_FIELD] 
    })
    opportunity;
    
    handleStageChange(event) {
        const fields = {};
        fields[STAGE_FIELD.fieldApiName] = event.detail.value;
        
        const recordInput = { fields };
        
        updateRecord(recordInput)
            .then(() => {
                this.showSuccess('Stage updated successfully');
            })
            .catch(error => {
                this.showError(error);
            });
    }
    
    showSuccess(message) {
        this.dispatchEvent(new ShowToastEvent({
            title: 'Success',
            message,
            variant: 'success'
        }));
    }
    
    showError(error) {
        this.dispatchEvent(new ShowToastEvent({
            title: 'Error',
            message: error.body?.message || 'Unknown error',
            variant: 'error'
        }));
    }
}

Phase 5: Testing & Rollout

Testing_Strategy:
  Unit_Tests:
    - LWC Jest tests (>80% coverage)
    - Apex unit tests (new service classes)
    - Integration tests
    
  UAT:
    - 50 power users for 2 weeks
    - A/B comparison with Visualforce
    - Performance benchmarking
    
  Rollout:
    Week_1: 10% of users (pilot)
    Week_2: 50% of users
    Week_3: 100% of users
    Rollback_Criteria: Error rate > 1% or Performance degradation > 20%

Outcome:

• 50% faster page load time (2s → 1s)
• 30% increase in mobile usage
• Zero rollback incidents
• User satisfaction: 4.7/5 (up from 3.2/5)

§7 · Tool Reference

§7.1 · Development Tools

§7.2 · Key APIs

§8 · Quality Checklist

§8.1 · Pre-Implementation Review

• Business value clearly defined
• Data model reviewed by architect
• Security impact assessment complete
• Governor limit analysis performed
• Mobile compatibility verified
• Accessibility (WCAG) requirements met

§8.2 · Code Quality Gates

• Apex code coverage >75%
• No hardcoded IDs
• CRUD/FLS checks in all queries
• Bulk-safe trigger patterns
• Error handling implemented
• Debug logs removed from production

§8.3 · Deployment Readiness

• All tests passing in sandbox
• Change set validated
• Rollback plan documented
• User communication sent
• Training materials ready
• Support team briefed

§9 · Risk Framework

§9.1 · Common Risks & Mitigations

§10 · Learning Resources

§10.1 · Essential Resources

§10.2 · Certifications

§11 · Quick Reference

§11.1 · Ohana Values in Action

TRUST → Build secure, reliable solutions
CUSTOMER SUCCESS → Measure features by customer outcomes
INNOVATION → Challenge the status quo, embrace Trailhead
EQUALITY → Design inclusive, accessible experiences
SUSTAINABILITY → Optimize for efficiency, minimize waste

§11.2 · Key Metrics

End of Skill Document

"We're not just building software; we're building a better world through business." — Marc Benioff

Workflow

Phase 1: Assessment

| Done | Phase completed | | Fail | Criteria not met |

• Gather requirements
• Analyze current state

Phase 2: Planning

| Done | Phase completed | | Fail | Criteria not met |

• Develop approach
• Set timeline

Phase 3: Execution

| Done | Phase completed | | Fail | Criteria not met |

• Implement solution
• Verify progress

Phase 4: Review

| Done | Phase completed | | Fail | Criteria not met |

• Validate outcomes
• Document lessons

Examples

Example 1: Standard Scenario

Input: Design and implement a salesforce engineer solution for a production system Output: Requirements Analysis → Architecture Design → Implementation → Testing → Deployment → Monitoring

Key considerations for salesforce-engineer:

• Scalability requirements
• Performance benchmarks
• Error handling and recovery
• Security considerations

Example 2: Edge Case

Input: Optimize existing salesforce engineer implementation to improve performance by 40% Output: Current State Analysis:

• Profiling results identifying bottlenecks
• Baseline metrics documented

Optimization Plan:

1. Algorithm improvement
2. Caching strategy
3. Parallelization

Expected improvement: 40-60% performance gain

§ 1.2 · Decision Framework — Weighted Criteria (0-100)

Composite Decision Rule:

• Score ≥85: Proceed
• Score 70-84: Conditional with monitoring
• Score <70: Stop and address issues

§ 1.3 · Thinking Patterns — Mental Models

Domain Benchmarks

Done Criteria

• All tasks completed per specification
• Quality standards met
• Stakeholder approval received

Fail Criteria

• Quality defects detected
• Requirements not met
• Timeline/budget overrun

Done Criteria

• All tasks completed per specification
• Quality standards met
• Stakeholder approval received

Fail Criteria

• Quality defects detected
• Requirements not met
• Timeline/budget overrun