sales-engineering

name	Sales Engineering
description	Supporting sales with technical expertise, demos, and proof-of-concept implementations

Sales Engineering

Current Level: Expert (Enterprise Scale)

Domain: Go-to-Market Tech

Skill ID: 148

---

Executive Summary

Sales Engineering enables supporting sales with technical expertise, demos, and proof-of-concept implementations. This capability is essential for bridging the gap between sales and engineering, demonstrating product value, and closing deals.

Strategic Necessity

• Sales Support: Provide technical support to sales
• Product Demonstrations: Demonstrate product value
• Proof of Concept: Build PoC implementations
• Technical Objections: Overcome technical objections
• Deal Closure: Help close deals

---

Technical Deep Dive

Sales Engineering Framework

┌─────────────────────────────────────────────────────────────────────────────┐
│                    Sales Engineering Framework                           │
│                                                                              │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐                  │
│  │   Sales      │    │   Technical  │    │   Demo      │                  │
│  │   Support   │───▶│   Expertise │───▶│   Creation  │                  │
│  └──────┬───────┘    └──────┬───────┘    └──────┬───────┘                  │
│         │                   │                   │                           │
│         ▼                   ▼                   ▼                           │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    Pre-Sales Activities                          │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐            │   │
│  │  │  Discovery│  │  Solution │  │  Demo     │  │  PoC      │            │   │
│  │  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘            │   │
│  └───────┼────────────┼────────────┼────────────┼────────────────────┘   │
│          │            │            │            │                         │
│          ▼            ▼            ▼            ▼                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    Sales Support                                │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐            │   │
│  │  │  Objection │  │  Technical │  │  Pricing  │  │  Contract │            │   │
│  │  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘            │   │
│  └───────┼────────────┼────────────┼────────────┼────────────────────┘   │
│          │            │            │            │                         │
│          ▼            ▼            ▼            ▼                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    Post-Sales Handoff                         │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐            │   │
│  │  │  Onboard  │  │  Training  │  │  Support  │  │  Success  │            │   │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────────────┘

Pre-Sales Activities

from typing import Dict, Any, List, Optional
from dataclasses import dataclass
from enum import Enum
import asyncio
import logging
from datetime import datetime

logger = logging.getLogger(__name__)

class OpportunityStage(Enum):
    """Opportunity stages"""
    DISCOVERY = "discovery"
    QUALIFICATION = "qualification"
    SOLUTION_DESIGN = "solution_design"
    DEMO = "demo"
    PROPOSAL = "proposal"
    NEGOTIATION = "negotiation"
    CLOSED_WON = "closed_won"
    CLOSED_LOST = "closed_lost"

class PoCStatus(Enum):
    """PoC status"""
    PLANNED = "planned"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"
    ACCEPTED = "accepted"
    REJECTED = "rejected"

@dataclass
class Opportunity:
    """Opportunity definition"""
    opportunity_id: str
    account_name: str
    contact_name: str
    stage: OpportunityStage
    value: float
    probability: float
    requirements: List[str]
    challenges: []
    created_at: 
    updated_at: 


 :
    
    demo_id: 
    opportunity_id: 
    title: 
    description: 
    features: []
    use_cases: []
    scheduled_at: 
    duration_minutes: 
    created_at: 


 :
    
    poc_id: 
    opportunity_id: 
    title: 
    description: 
    scope: []
    success_criteria: []
    status: PoCStatus
    start_date: 
    end_date: 
    created_at: 

 :
    
    
     ():
        .config = config
        .opportunity_store = OpportunityStore(config[])
        .demo_creator = DemoCreator(config[])
        .poc_builder = PoCBuilder(config[])
        
      () -> [, ]:
        
        logger.info()
        
        
        requirements_analysis =  ._analyze_requirements(opportunity)
        
        
        challenges =  ._identify_challenges(opportunity)
        
        
        solutions =  ._recommend_solutions(opportunity, requirements_analysis, challenges)
        
        
        results = {
            : opportunity.opportunity_id,
            : requirements_analysis,
            : challenges,
            : solutions,
            : datetime.utcnow().isoformat()
        }
        
        logger.info()
        
         results
    
      () -> [, ]:
        
        analysis = {
            : [],
            : [],
            : [],
            : [],
            : []
        }
        
        
         requirement  opportunity.requirements:
            
            req_type = ._categorize_requirement(requirement)
            
            
            analysis[].append(requirement)
        
         analysis
    
     () -> :
        
        
           requirement.lower():
             
           requirement.lower():
             
           requirement.lower():
             
           requirement.lower():
             
        :
             
    
      () -> [[, ]]:
        
        challenges = []
        
        
         challenge  opportunity.challenges:
            challenge_analysis = {
                : challenge,
                : ._assess_severity(challenge),
                : ._suggest_mitigation(challenge)
            }
            challenges.append(challenge_analysis)
        
         challenges
    
     () -> :
        
        
           challenge.lower():
             
           challenge.lower():
             
        :
             
    
     () -> :
        
        
         
    
      () -> [[, ]]:
        
        solutions = []
        
        
         req_type, requirements  requirements_analysis.items():
             requirements:
                solution = {
                    : req_type.replace(, ),
                    : requirements,
                    : ._propose_solution(req_type, requirements),
                    : ._estimate_effort(req_type, requirements),
                    : ._estimate_timeline(req_type, requirements)
                }
                solutions.append(solution)
        
        
         challenge  challenges:
             challenge[] == :
                solution = {
                    : ,
                    : challenge[],
                    : challenge[],
                    : ,
                    : 
                }
                solutions.append(solution)
        
         solutions
    
     () -> :
        
        
         
    
     () -> :
        
        
         
    
     () -> :
        
        
         
    
      () -> Demo:
        
        logger.info()
        
        
        demo_id = ._generate_demo_id()
        
        
        demo =  .demo_creator.create_demo(
            demo_id=demo_id,
            opportunity_id=opportunity.opportunity_id,
            title=,
            description=._generate_demo_description(opportunity),
            features=._select_demo_features(opportunity),
            use_cases=._select_use_cases(opportunity),
            scheduled_at=._schedule_demo(opportunity),
            duration_minutes=
        )
        
        logger.info()
        
         demo
    
     () -> :
        
         
    
     () -> []:
        
        
         []
    
     () -> []:
        
        
         []
    
     () -> :
        
        
         datetime.utcnow().isoformat()
    
      () -> ProofOfConcept:
        
        logger.info()
        
        
        poc_id = ._generate_poc_id()
        
        
        scope = ._define_poc_scope(opportunity)
        
        
        success_criteria = ._define_success_criteria(opportunity)
        
        
        poc =  .poc_builder.build_poc(
            poc_id=poc_id,
            opportunity_id=opportunity.opportunity_id,
            title=,
            description=._generate_poc_description(opportunity),
            scope=scope,
            success_criteria=success_criteria,
            status=PoCStatus.PLANNED,
            start_date=._calculate_poc_start_date(),
            end_date=._calculate_poc_end_date()
        )
        
        logger.info()
        
         poc
    
     () -> []:
        
        
         []
    
     () -> []:
        
        
         []
    
     () -> :
        
         
    
     () -> :
        
         datetime  timedelta
        start_date = datetime.utcnow() + timedelta(weeks=)
         start_date.isoformat()
    
     () -> :
        
         datetime  timedelta
        end_date = datetime.utcnow() + timedelta(weeks=)
         end_date.isoformat()
    
     () -> :
        
         uuid
         
    
     () -> :
        
         uuid
         

 :
    
    
     ():
        .config = config
        
      () -> Demo:
        
        
         ._create_demo_environment(demo_id)
        
        
         ._configure_demo_data(demo_id, features)
        
        
        demo = Demo(
            demo_id=demo_id,
            opportunity_id=opportunity_id,
            title=title,
            description=description,
            features=features,
            use_cases=use_cases,
            scheduled_at=scheduled_at,
            duration_minutes=duration_minutes,
            created_at=datetime.utcnow().isoformat()
        )
        
         demo
    
      ():
        
        
        
    
      ():
        
        
        

 :
    
    
     ():
        .config = config
        
      () -> ProofOfConcept:
        
        
         ._create_poc_environment(poc_id)
        
        
         ._implement_poc(poc_id, scope)
        
        
         ._test_poc(poc_id, success_criteria)
        
        
        poc = ProofOfConcept(
            poc_id=poc_id,
            opportunity_id=opportunity_id,
            title=title,
            description=description,
            scope=scope,
            success_criteria=success_criteria,
            status=status,
            start_date=start_date,
            end_date=end_date,
            created_at=datetime.utcnow().isoformat()
        )
        
         poc
    
      ():
        
        
        
    
      ():
        
        
        
    
      ():
        
        
        

 :
    
    
     ():
        .config = config
        
      ():
        
        
        
    
      () -> Opportunity:
        
        
         
    
      ():
        
        
        

Sales Support

class SalesSupport:
    """Sales support specialist"""
    
    def __init__(self, config: Dict[str, Any]):
        self.config = config
        self.objection_handler = ObjectionHandler(config['objections'])
        self.pricing_specialist = PricingSpecialist(config['pricing'])
        self.contract_specialist = ContractSpecialist(config['contracts'])
        
    async def handle_objections(
        self,
        opportunity: Opportunity,
        objections: List[str]
    ) -> Dict[str, Any]:
        """Handle sales objections"""
        logger.info(f"Handling objections for opportunity: {opportunity.opportunity_id}")
        
        # Analyze objections
        analyzed_objections = await self._analyze_objections(objections)
        
        # Prepare responses
        responses = await self._prepare_objection_responses(analyzed_objections)
        
        # Compile results
        results = {
            'opportunity_id': opportunity.opportunity_id,
            'objections': analyzed_objections,
            'responses': responses,
            'handled_at': datetime.utcnow().isoformat()
        }
        
        logger.info(f"Objections handled: {opportunity.opportunity_id}")
        
         results
    
      () -> [[, ]]:
        
        analyzed = []
        
         objection  objections:
            analysis = {
                : objection,
                : ._categorize_objection(objection),
                : ._assess_objection_severity(objection),
                : ._identify_root_cause(objection)
            }
            analyzed.append(analysis)
        
         analyzed
    
     () -> :
        
        
           objection.lower():
             
           objection.lower():
             
           objection.lower():
             
           objection.lower():
             
        :
             
    
     () -> :
        
        
         
    
     () -> :
        
        
         
    
      () -> [[, ]]:
        
        responses = []
        
         objection  analyzed_objections:
            response = {
                : objection[],
                : objection[],
                : ._generate_response(objection),
                : ._gather_evidence(objection),
                : ._suggest_follow_up(objection)
            }
            responses.append(response)
        
         responses
    
     () -> :
        
        
         
    
     () -> []:
        
        
         []
    
     () -> :
        
        
         
    
      () -> [, ]:
        
        logger.info()
        
        
        value_analysis =  ._analyze_opportunity_value(opportunity)
        
        
        pricing_model =  .pricing_specialist.recommend_pricing_model(
            opportunity,
            value_analysis
        )
        
        
        pricing =  .pricing_specialist.calculate_pricing(
            opportunity,
            pricing_model
        )
        
        
        results = {
            : opportunity.opportunity_id,
            : value_analysis,
            : pricing_model,
            : pricing,
            : datetime.utcnow().isoformat()
        }
        
        logger.info()
        
         results
    
      () -> [, ]:
        
         {
            : opportunity.value,
            : [],
            : {}
        }
    
      () -> [, ]:
        
        logger.info()
        
        
        contract_terms =  .contract_specialist.prepare_contract_terms(opportunity)
        
        
        negotiation_points =  ._identify_negotiation_points(opportunity)
        
        
        negotiation_strategy = ._prepare_negotiation_strategy(
            contract_terms,
            negotiation_points
        )
        
        
        results = {
            : opportunity.opportunity_id,
            : contract_terms,
            : negotiation_points,
            : negotiation_strategy,
            : datetime.utcnow().isoformat()
        }
        
        logger.info()
        
         results
    
     () -> [, ]:
        
         {
            : [],
            : [],
            : [],
            : []
        }
    
      () -> [[, ]]:
        
        
         []

 :
    
    
     ():
        .config = config

 :
    
    
     ():
        .config = config
        
      () -> :
        
        
         
    
      () -> [, ]:
        
        
         {}

 :
    
    
     ():
        .config = config
        
      () -> [, ]:
        
        
         {}

---

Tooling & Tech Stack

Demo Tools

• Zoom: Video conferencing
• Google Meet: Video conferencing
• Loom: Video recording
• OBS Studio: Screen recording
• Figma: Design

PoC Tools

• Docker: Containerization
• Kubernetes: Orchestration
• AWS: Cloud platform
• Azure: Cloud platform
• GCP: Cloud platform

CRM Tools

• Salesforce: CRM
• HubSpot: CRM
• Pipedrive: CRM
• Zoho CRM: CRM
• Monday.com: CRM

Collaboration Tools

• Slack: Team communication
• Microsoft Teams: Team collaboration
• Notion: Documentation
• Confluence: Documentation
• Miro: Visual collaboration

---

Configuration Essentials

Sales Engineering Configuration

# config/sales_engineering_config.yaml
sales_engineering:
  discovery:
    enabled: true
    methods:
      - "discovery_call"
      - "technical_assessment"
      - "requirements_gathering"
    
    deliverables:
      - "requirements_document"
      - "solution_proposal"
      - "architecture_diagram"
  
  demo:
    enabled: true
    duration_minutes: 60
    preparation_time: "2-4 hours"
    
    environment:
      type: "sandbox"
      data_source: "demo_data"
      refresh_frequency: "daily"
    
    features:
      customization: true
      branding: true
      use_case_specific: true
  
  poc:
    enabled: true
    duration_weeks: 4
    
    scope:
      max_features: 5
      max_integrations: 3
      max_users: 10
    
    success_criteria:
       
       
       
       
    
    
       
       
       
       
  
  
    
        
        
           
           
           
      
        
        
           
           
           
      
        
        
           
           
           
      
        
        
           
           
           
  
  
    
       
       
       
    
    
       
         
       
         
  
  
    
       
       
       
    
    
      
         
         
         
      
      
         
         
         
      
      
         
         
         

---

Code Examples

Good: Complete Sales Engineering Workflow

# sales_engineering/workflow.py
import asyncio
import logging
from typing import Dict, Any

from sales_engineering.engineer import SalesEngineer
from sales_engineering.support import SalesSupport

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

async def run_sales_engineering():
    """Run sales engineering workflow"""
    logger.info("=" * 60)
    logger.info("Sales Engineering Workflow")
    logger.info("=" * 60)
    
    # Load configuration
    config = load_config('config/sales_engineering_config.yaml')
    
    # Create opportunity
    opportunity = create_sample_opportunity()
    
    # Step 1: Support discovery
    logger.info("\n" + "=" * 60)
    logger.info("Step 1: Supporting Discovery")
    logger.info("=" * 60)
    
    engineer = SalesEngineer(config)
    discovery_results = await engineer.support_discovery(opportunity)
    
    logger.info("Discovery supported")
    print_discovery_results(discovery_results)
    
    # Step 2: Create demo
    logger.info("\n" + "=" * 60)
    logger.info("Step 2: Creating Demo")
    logger.info("=" * 60)
    
    demo = await engineer.create_demo(opportunity)
    
    logger.info(f"Demo created: {demo.demo_id}")
    print_demo_summary(demo)
    
    
    logger.info( +  * )
    logger.info()
    logger.info( * )
    
    poc =  engineer.build_poc(opportunity)
    
    logger.info()
    print_poc_summary(poc)
    
    
    logger.info( +  * )
    logger.info()
    logger.info( * )
    
    support = SalesSupport(config)
    objections = [
        ,
        ,
        
    ]
    
    objection_results =  support.handle_objections(opportunity, objections)
    
    logger.info()
    print_objection_results(objection_results)
    
    
    print_summary(opportunity, discovery_results, demo, poc, objection_results)

 () -> Opportunity:
    
     Opportunity(
        opportunity_id=,
        account_name=,
        contact_name=,
        stage=OpportunityStage.DISCOVERY,
        value=,
        probability=,
        requirements=[
            ,
            ,
            
        ],
        challenges=[
            ,
            
        ],
        created_at=datetime.utcnow().isoformat(),
        updated_at=datetime.utcnow().isoformat()
    )

 ():
    
    ()
    ()
     req_type, requirements  results[].items():
        ()
    ()
    ()

 ():
    
    ()
    ()
    ()
    ()
    ()
    ()
    ()

 ():
    
    ()
    ()
    ()
    ()
    ()
    ()
    ()
    ()

 ():
    
    ()
    ()
     objection  results[]:
        ()
    ()

 ():
    
    ( +  * )
    ()
    ( * )
    ()
    ()
    ()
    ()
    ()
    ()
    ()
    ()

 () -> [, ]:
    
     yaml
     (filename, )  f:
         yaml.safe_load(f)

  ():
    
     run_sales_engineering()

 __name__ == :
    asyncio.run(main())

Bad: Anti-pattern Example

# BAD: No discovery
def bad_sales_engineering():
    # No discovery
    pass

# BAD: No demo
def bad_sales_engineering():
    # No demo
    support_discovery()

# BAD: No PoC
def bad_sales_engineering():
    # No PoC
    support_discovery()
    create_demo()

# BAD: No objection handling
def bad_sales_engineering():
    # No objection handling
    support_discovery()
    create_demo()
    build_poc()

---

Standards, Compliance & Security

Industry Standards

• Sales Engineering: Sales engineering best practices
• Pre-Sales: Pre-sales best practices
• Solution Selling: Solution selling methodology
• Value Selling: Value selling methodology

Security Best Practices

• Data Protection: Protect customer data
• Access Control: RBIC for demo/PoC environments
• Audit Logging: Log all sales engineering activities
• Confidentiality: Maintain confidentiality

Compliance Requirements

• GDPR: Data protection compliance
• Data Privacy: Protect customer privacy
• Contract Compliance: Follow contract requirements
• Industry Regulations: Follow industry regulations

---

Quick Start

1. Install Dependencies

pip install pyyaml

2. Configure Sales Engineering

# Copy example config
cp config/sales_engineering_config.yaml.example config/sales_engineering_config.yaml

# Edit configuration
vim config/sales_engineering_config.yaml

3. Run Sales Engineering

python sales_engineering/workflow.py

4. View Results

# View opportunities
cat sales_engineering/results/opportunities.json

# View demos
cat sales_engineering/results/demos/

# View PoCs
cat sales_engineering/results/pocs/

---

Production Checklist

Discovery

• Discovery process defined
• Requirements gathering template created
• Technical assessment framework defined
• Solution proposal template created
• Architecture diagram tool selected

Demo

• Demo environment set up
• Demo data configured
• Demo script created
• Demo recording capability enabled
• Demo scheduling process defined

PoC

• PoC process defined
• PoC scope template created
• Success criteria defined
• PoC environment set up
• PoC documentation template created

Objection Handling

• Common objections cataloged
• Response templates created
• Evidence repository created
• Follow-up process defined
• Training completed

Pricing

• Pricing models defined
• Discount policy defined
• ROI calculator created
• Competitive pricing analysis completed
• Approval process defined

Contracts

• Contract templates created
• Terms defined
• SLA levels defined
• Legal review process defined
• Contract management system configured

---

Anti-patterns

❌ Avoid These Practices

1. No Discovery

   # BAD: No discovery
   pass
   

2. No Demo

   # BAD: No demo
   support_discovery()
   

3. No PoC

   # BAD: No PoC
   support_discovery()
   create_demo()
   

4. No Objection Handling

   # BAD: No objection handling
   support_discovery()
   create_demo()
   build_poc()
   

✅ Follow These Practices

1. Support Discovery

   # GOOD: Support discovery
   engineer = SalesEngineer(config)
   results = await engineer.support_discovery(opportunity)
   

2. Create Demo

   # GOOD: Create demo
   demo = await engineer.create_demo(opportunity)
   

3. Build PoC

   # GOOD: Build PoC
   poc = await engineer.build_poc(opportunity)
   

4. Handle Objections

   # GOOD: Handle objections
   support = SalesSupport(config)
   results = await support.handle_objections(opportunity, objections)
   

---

Unit Economics & KPIs

Development Costs

• Initial Setup: 20-40 hours
• Discovery Framework: 20-40 hours
• Demo Creation: 40-80 hours
• PoC Building: 60-120 hours
• Total: 140-280 hours

Operational Costs

• Demo Environment: $200-1000/month
• PoC Environment: $500-2000/month
• CRM Tools: $100-500/month
• Collaboration Tools: $50-200/month

ROI Metrics

• Win Rate: 20-40% improvement
• Deal Size: 30-50% improvement
• Sales Cycle: 30-50% reduction
• Customer Satisfaction: 40-60% improvement

KPI Targets

• Discovery Completion Rate: > 90%
• Demo Success Rate: > 80%
• PoC Acceptance Rate: > 70%
• Obection Resolution Rate: > 85%
• Win Rate: > 30%

---

Integration Points / Related Skills

Upstream Skills

• 136. Business to Technical Spec: Requirements
• 137. API-First Product Strategy: API design
• 138. Platform Product Design: Platform design
• 146. Developer Relations & Community: Community building
• 147. Technical Content Marketing: Content marketing

Parallel Skills

• 149. Enterprise Sales Alignment: Sales alignment
• 150. Partner Program Design: Partner programs
• 151. Analyst Relations: Analyst relations

Downstream Skills

• 152. Launch Strategy Execution: Launch strategy

Cross-Domain Skills

• 18. Project Management: Project planning
• 81. SaaS FinOps Pricing: Pricing strategy
• 82. Technical Product Management: Product management
• 84. Compliance AI Governance: Compliance

---

References & Resources

Documentation

• Sales Engineering Guide
• Pre-Sales Best Practices
• Solution Selling
• Value Selling

Best Practices

• Sales Engineering
• Demo Best Practices
• PoC Best Practices

Tools & Libraries

• Zoom
• Loom
• Salesforce
• HubSpot
• Slack