ElasticFlow
AI SkillScore RFPSales

When an RFP lands Friday with a Monday deadline, /sales-engineer scores coverage and gives you a bid/no-bid call in 30 minutes. — Claude Skill

A Claude Skill for Claude Code by Alireza Rezvani — run /sales-engineer in Claude·Updated ·v1.0.0

Compatible withChatGPT·Claude·Gemini·OpenClaw

Score RFPs, build competitive matrices, plan POCs in pre-sales

  • RFP analyzer with coverage scoring (Full / Partial / Planned / Gap) and bid/no-bid recommendation: Bid (>70% + ≤3 must-have gaps), Conditional, No-Bid
  • Competitive matrix builder: feature-by-feature scoring (Full=3, Partial=2, Limited=1, None=0), weighted competitive scores, differentiators, vulnerabilities, win themes
  • POC planner with 5-week phased timeline, success criteria, evaluation scorecard (>60% to convert), and go/no-go recommendation framework
  • 5-phase pre-sales workflow: Discovery → Solution Design → Demo → POC → Proposal & Closing
  • Templates: technical proposal, demo script, POC scorecard, sample RFP data

Who this is for

Sales Engineer

Score RFP coverage and get bid/no-bid recommendation before committing 40 hours to a response

See skills for this role
Account Executive

Build competitive matrix and demo script for enterprise deals with multiple competitors

See skills for this role
Sales Manager

Standardize POC planning across the team with success criteria and go/no-go scorecards

See skills for this role

What it does

RFP landed Friday, deadline Monday

50-page RFP just dropped and the SE team is debating bid vs no-bid. /sales-engineer scores requirement coverage (Must-Have ×3, Should-Have ×2, Nice-to-Have ×1), flags coverage gaps, and gives you a bid/no-bid call in 30 minutes — not 8 hours of arguing.

Enterprise deal has 3 competitors and you need a battle card

AE asks for a competitive battlecard before the demo. /sales-engineer builds a feature-by-feature comparison matrix with weighted scores, identifies your differentiators (where you score Full and they score Partial/None), and surfaces vulnerabilities to address.

Customer wants a 4-week POC before they sign

Procurement requires a structured POC. /sales-engineer plans Setup (week 1), Core Testing (weeks 2-3), Advanced Testing (week 4), and Evaluation (week 5) with weekly success criteria and a go/no-go scorecard at the end.

Lost a deal, need win/loss analysis

VP asks why you lost the Acme deal. /sales-engineer reviews phase-by-phase: was it RFP coverage, competitive positioning, demo execution, or POC scoring — and which phase to invest in next quarter.

How it works

1

Phase 1 — Discovery: run rfp_response_analyzer on requirements JSON, get coverage score and must-have gap count

2

Phase 2 — Solution Design: run competitive_matrix_builder, get differentiators per priority and vulnerabilities to address

3

Phase 3 — Demo: build script from demo_script_template, validation checkpoint against must-have requirements

4

Phase 4 — POC: run poc_planner with phased timeline, success criteria, and weekly milestones

5

Phase 5 — Closing: technical proposal from template_proposal, win/loss analysis post-decision

Example

Your RFP (50 pages, 84 requirements)
Acme Inc — RFP for Customer Data Platform
84 requirements: 22 Must-Have, 38 Should-Have, 24 Nice-to-Have
Deadline: Monday 5pm (3 days)
3 known competitors: Segment, mParticle, RudderStack
30 minutes later
Coverage Score
Overall coverage: 73% (Bid threshold: >70%)
Must-Have:   18 Full / 2 Partial / 1 Planned / 1 Gap   (95% covered)
Should-Have: 24 Full / 9 Partial / 5 Gap                 (87% covered)
Nice-to-Have: 11 Full / 8 Partial / 5 Gap                (79% covered)
Recommendation: BID
✅ Coverage 73% (>70% threshold)
✅ Must-Have gaps: 1 (≤3 threshold)

The one Must-Have gap is API rate limiting at 10K/sec — we support 5K/sec. Conditional bid possible if we commit to roadmap delivery in Q3.
Must-Have Gaps to Address
GAP — Req #14: API rate limiting 10K/sec → propose Q3 roadmap commitment
PARTIAL — Req #28: SOC 2 Type II → we have Type I, get attestation by deadline
PARTIAL — Req #41: Custom retention rules → workaround via webhooks documented
Win Themes vs Competitors
Differentiator (Full vs competitor Partial/None):
✓ Real-time identity resolution (we Full, Segment Partial)
✓ EU data residency (we Full, mParticle None)
✓ Native warehouse sync (we Full, RudderStack Partial)

Vulnerability: Throughput at 5K/sec (Segment Full at 50K/sec)
Next Steps
→ Day 1: Draft response sections 1-4 using technical_proposal_template
→ Day 2: Demo prep — focus on identity resolution + warehouse sync (differentiators)
→ Day 3: Final review with eng on rate limiting commitment, submit by 5pm

Metrics this improves

Competitive Win Rate
Differentiators per priority
Sales
Deal Velocity
5-week POC vs 8
Sales
Close Rate
No-Bid filter saves 40hrs
Sales

Works with

Google Drive
manual

Read RFP documents and store generated technical proposals

Salesforce
manual

Pull deal context, opportunity stage, and competitor mentions for RFP scoring

HubSpot
manual

Alternative CRM source for opportunity and deal data

Notion
manual

Store technical proposals, demo scripts, and POC plans in Notion

Want to use Sales Engineer Skill?

Choose how to get started.

Run in Claude Code
Free. Open source.

Install and run this skill locally on your computer.

1
Install Claude Code

Open a terminal on your computer and paste this command:

2
Install the skill

This downloads the skill with all its files to your computer:

Add -g at the end to make it available in all your projects.

3
Run it

Start Claude Code, then type the command:

then
View source on GitHub
Use on ElasticFlow
Team and collaboration features

Run skills from your browser. Share results, manage access, collaborate with your team. No terminal needed.

Free 14-day trial. Cancel anytime.

View on GitHub

Sales Engineer Skill

5-Phase Workflow

Phase 1: Discovery & Research

Objective: Understand customer requirements, technical environment, and business drivers.

Checklist:

  • Conduct technical discovery calls with stakeholders
  • Map customer's current architecture and pain points
  • Identify integration requirements and constraints
  • Document security and compliance requirements
  • Assess competitive landscape for this opportunity

Tools: Run rfp_response_analyzer.py to score initial requirement alignment.

python scripts/rfp_response_analyzer.py assets/sample_rfp_data.json --format json > phase1_rfp_results.json

Output: Technical discovery document, requirement map, initial coverage assessment.

Validation checkpoint: Coverage score must be >50% and must-have gaps ≤3 before proceeding to Phase 2. Check with:

python scripts/rfp_response_analyzer.py assets/sample_rfp_data.json --format json | python -c "import sys,json; r=json.load(sys.stdin); print('PROCEED' if r['coverage_score']>50 and r['must_have_gaps']<=3 else 'REVIEW')"

Phase 2: Solution Design

Objective: Design a solution architecture that addresses customer requirements.

Checklist:

  • Map product capabilities to customer requirements
  • Design integration architecture
  • Identify customization needs and development effort
  • Build competitive differentiation strategy
  • Create solution architecture diagrams

Tools: Run competitive_matrix_builder.py using Phase 1 data to identify differentiators and vulnerabilities.

python scripts/competitive_matrix_builder.py competitive_data.json --format json > phase2_competitive.json

python -c "import json; d=json.load(open('phase2_competitive.json')); print('Differentiators:', d['differentiators']); print('Vulnerabilities:', d['vulnerabilities'])"

Output: Solution architecture, competitive positioning, technical differentiation strategy.

Validation checkpoint: Confirm at least one strong differentiator exists per customer priority before proceeding to Phase 3. If no differentiators found, escalate to Product Team (see Integration Points).

Phase 3: Demo Preparation & Delivery

Objective: Deliver compelling technical demonstrations tailored to stakeholder priorities.

Checklist:

  • Build demo environment matching customer's use case
  • Create demo script with talking points per stakeholder role
  • Prepare objection handling responses
  • Rehearse failure scenarios and recovery paths
  • Collect feedback and adjust approach

Templates: Use assets/demo_script_template.md for structured demo preparation.

Output: Customized demo, stakeholder-specific talking points, feedback capture.

Validation checkpoint: Demo script must cover every must-have requirement flagged in phase1_rfp_results.json before delivery. Cross-reference with:

python -c "import json; rfp=json.load(open('phase1_rfp_results.json')); [print('UNCOVERED:', r) for r in rfp['must_have_requirements'] if r['coverage']=='Gap']"

Phase 4: POC & Evaluation

Objective: Execute a structured proof-of-concept that validates the solution.

Checklist:

  • Define POC scope, success criteria, and timeline
  • Allocate resources and set up environment
  • Execute phased testing (core, advanced, edge cases)
  • Track progress against success criteria
  • Generate evaluation scorecard

Tools: Run poc_planner.py to generate the complete POC plan.

python scripts/poc_planner.py poc_data.json --format json > phase4_poc_plan.json

python -c "import json; p=json.load(open('phase4_poc_plan.json')); print('Go/No-Go:', p['recommendation'])"

Templates: Use assets/poc_scorecard_template.md for evaluation tracking.

Output: POC plan, evaluation scorecard, go/no-go recommendation.

Validation checkpoint: POC conversion requires scorecard score >60% across all evaluation dimensions (functionality, performance, integration, usability, support). If score <60%, document gaps and loop back to Phase 2 for solution redesign.

Phase 5: Proposal & Closing

Objective: Deliver a technical proposal that supports the commercial close.

Checklist:

  • Compile POC results and success metrics
  • Create technical proposal with implementation plan
  • Address outstanding objections with evidence
  • Support pricing and packaging discussions
  • Conduct win/loss analysis post-decision

Templates: Use assets/technical_proposal_template.md for the proposal document.

Output: Technical proposal, implementation timeline, risk mitigation plan.

Python Automation Tools

1. RFP Response Analyzer

Script: scripts/rfp_response_analyzer.py

Purpose: Parse RFP/RFI requirements, score coverage, identify gaps, and generate bid/no-bid recommendations.

Coverage Categories: Full (100%), Partial (50%), Planned (25%), Gap (0%).
Priority Weighting: Must-Have 3×, Should-Have 2×, Nice-to-Have 1×.

Bid/No-Bid Logic:

  • Bid: Coverage >70% AND must-have gaps ≤3
  • Conditional Bid: Coverage 50–70% OR must-have gaps 2–3
  • No-Bid: Coverage <50% OR must-have gaps >3

Usage:

python scripts/rfp_response_analyzer.py assets/sample_rfp_data.json            # human-readable
python scripts/rfp_response_analyzer.py assets/sample_rfp_data.json --format json  # JSON output
python scripts/rfp_response_analyzer.py --help

Input Format: See assets/sample_rfp_data.json for the complete schema.

2. Competitive Matrix Builder

Script: scripts/competitive_matrix_builder.py

Purpose: Generate feature comparison matrices, calculate competitive scores, identify differentiators and vulnerabilities.

Feature Scoring: Full (3), Partial (2), Limited (1), None (0).

Usage:

python scripts/competitive_matrix_builder.py competitive_data.json              # human-readable
python scripts/competitive_matrix_builder.py competitive_data.json --format json  # JSON output

Output Includes: Feature comparison matrix, weighted competitive scores, differentiators, vulnerabilities, and win themes.

3. POC Planner

Script: scripts/poc_planner.py

Purpose: Generate structured POC plans with timeline, resource allocation, success criteria, and evaluation scorecards.

Default Phase Breakdown:

  • Week 1: Setup — environment provisioning, data migration, configuration
  • Weeks 2–3: Core Testing — primary use cases, integration testing
  • Week 4: Advanced Testing — edge cases, performance, security
  • Week 5: Evaluation — scorecard completion, stakeholder review, go/no-go

Usage:

python scripts/poc_planner.py poc_data.json              # human-readable
python scripts/poc_planner.py poc_data.json --format json  # JSON output

Output Includes: Phased POC plan, resource allocation, success criteria, evaluation scorecard, risk register, and go/no-go recommendation framework.

Reference Knowledge Bases

ReferenceDescription
references/rfp-response-guide.mdRFP/RFI response best practices, compliance matrix, bid/no-bid framework
references/competitive-positioning-framework.mdCompetitive analysis methodology, battlecard creation, objection handling
references/poc-best-practices.mdPOC planning methodology, success criteria, evaluation frameworks

Asset Templates

TemplatePurpose
assets/technical_proposal_template.mdTechnical proposal with executive summary, solution architecture, implementation plan
assets/demo_script_template.mdDemo script with agenda, talking points, objection handling
assets/poc_scorecard_template.mdPOC evaluation scorecard with weighted scoring
assets/sample_rfp_data.jsonSample RFP data for testing the analyzer
assets/expected_output.jsonExpected output from rfp_response_analyzer.py

Integration Points

  • Marketing Skills - Leverage competitive intelligence and messaging frameworks from ../../marketing-skill/
  • Product Team - Coordinate on roadmap items flagged as "Planned" in RFP analysis from ../../product-team/
  • C-Level Advisory - Escalate strategic deals requiring executive engagement from ../../c-level-advisor/
  • Customer Success - Hand off POC results and success criteria to CSM from ../customer-success-manager/

Last Updated: February 2026 Status: Production-ready Tools: 3 Python automation scripts References: 3 knowledge base documents Templates: 5 asset files