Sales Engineer

Automate and integrate Sales Engineer workflows to accelerate technical sales

Category: productivity Source: alirezarezvani/claude-skills

Sales Engineer is a community skill for technical pre-sales support, covering demo preparation, proof of concept design, technical discovery, solution architecture, and RFP response automation for technical selling.

What Is This?

Overview

Sales Engineer provides tools for supporting technical sales processes from discovery through deal closure. It covers demo preparation that builds customized product demonstrations tailored to prospect use cases and requirements, proof of concept design that structures evaluation criteria and success metrics for pilot engagements, technical discovery that guides questioning frameworks to uncover prospect architecture and integration needs, solution architecture that maps product capabilities to prospect requirements with deployment recommendations, and RFP response automation that generates technical answers from product knowledge bases. The skill helps technical sellers win complex deals.

Who Should Use This

This skill serves sales engineers supporting enterprise deals, solution architects designing prospect implementations, and pre-sales teams responding to technical evaluations and RFPs.

Why Use It?

Problems It Solves

Demo preparation for each prospect requires significant time to customize generic product presentations. Proof of concept projects lack structured success criteria leading to open-ended evaluations. Technical discovery conversations miss important questions about integration requirements and constraints. RFP responses require compiling technical details from multiple sources under tight deadlines.

Core Highlights

Demo builder customizes product demonstrations for specific prospect scenarios. POC designer structures evaluation criteria and timelines. Discovery guide provides technical questioning frameworks. RFP responder generates technical answers from knowledge bases.

How to Use It?

Basic Usage

from dataclasses import (
  dataclass, field)

@dataclass
class Discovery:
  company: str
  industry: str
  questions: list = field(
    default_factory=list)
  findings: dict = field(
    default_factory=dict)

  def add_finding(
    self,
    category: str,
    detail: str
  ):
    if category not in (
      self.findings
    ):
      self.findings[
        category] = []
    self.findings[
      category].append(
        detail)

  def summary(self):
    lines = [
      f'Discovery: '
      f'{self.company}',
      f'Industry: '
      f'{self.industry}',
      '']
    for cat, items in (
      self.findings.items()
    ):
      lines.append(
        f'{cat}:')
      for item in items:
        lines.append(
          f'  - {item}')
    return '\n'.join(
      lines)

disc = Discovery(
  'Acme Corp', 'fintech')
disc.add_finding(
  'Architecture',
  'AWS multi-region')
disc.add_finding(
  'Integration',
  'REST APIs required')
disc.add_finding(
  'Requirements',
  'SOC 2 compliance')
print(disc.summary())

Real-World Examples

from dataclasses import (
  dataclass, field)
from datetime import (
  date, timedelta)

@dataclass
class POCPlan:
  prospect: str
  start_date: date
  duration_days: int = 14
  criteria: list = field(
    default_factory=list)
  milestones: list = field(
    default_factory=list)

  def add_criterion(
    self,
    name: str,
    metric: str,
    target: str
  ):
    self.criteria.append(
      {'name': name,
       'metric': metric,
       'target': target})

  def add_milestone(
    self,
    day: int,
    task: str
  ):
    d = self.start_date +\
      timedelta(days=day)
    self.milestones.append(
      {'date': str(d),
       'task': task})

  def plan(self):
    return {
      'prospect':
        self.prospect,
      'end': str(
        self.start_date +
        timedelta(
          days=self
            .duration_days)),
      'criteria':
        self.criteria,
      'milestones':
        self.milestones}

poc = POCPlan(
  'Acme Corp',
  date(2025, 7, 1))
poc.add_criterion(
  'Latency', 'p99 ms',
  '<100ms')
poc.add_criterion(
  'Throughput', 'req/s',
  '>10000')
poc.add_milestone(
  1, 'Environment setup')
poc.add_milestone(
  7, 'Integration test')
poc.add_milestone(
  14, 'Results review')
print(poc.plan())

Advanced Tips

Define measurable success criteria before starting any POC to prevent scope creep and ensure objective evaluation. Build a reusable demo environment that can be quickly customized with prospect-specific data. Document technical findings during discovery for handoff to implementation teams after deal closure.

When to Use It?

Use Cases

Plan a structured proof of concept with success criteria and milestone timeline. Conduct technical discovery to map prospect architecture and integration requirements. Generate RFP responses by matching questions to product capability documentation.

Important Notes

Requirements

Product knowledge base for demo customization and RFP response generation. Demo environment that can be configured for different prospect scenarios. Technical discovery frameworks aligned with product capabilities and integration patterns.

Usage Recommendations

Do: customize every demo to reflect the prospect's specific use case and industry context. Set clear POC timelines and success criteria before beginning the evaluation. Follow up technical discovery with a written summary for prospect alignment.

Don't: run open-ended POC evaluations without defined success criteria and deadlines. Show generic demos that do not connect to the prospect's stated requirements. Promise technical capabilities that require custom development without engineering confirmation.

Limitations

Demo environments may not fully replicate production conditions that prospects will encounter. POC results in controlled settings may differ from actual production performance. RFP response automation requires a maintained knowledge base that reflects current product capabilities.