Prismatic Presales

Overview

Prismatic Presales provides tooling for customer demonstrations, proof-of-concept deployments, and presales intelligence gathering. It generates tailored demo environments showcasing platform capabilities against prospect-relevant scenarios, and supports the sales process with automated competitive intelligence. Unlike static demo scripts, Presales dynamically provisions isolated Phoenix LiveView instances populated with prospect-specific data, allowing sales engineers to demonstrate real platform functionality rather than slide decks. The module embodies the platform's philosophy that the best way to sell security intelligence is to demonstrate it against the prospect's own infrastructure.

The module draws on the platform's OSINT capabilities to enrich the presales process itself. Before a customer engagement, Presales automatically collects publicly available information about the prospect's domain, technology stack, and security rating using Prismatic Perimeter scanning. This means the first demo already shows real findings for the prospect's own attack surface, making the value proposition immediately tangible. The NABLA framework's confidence scoring ensures that every finding presented to prospects includes epistemic rigor -- no unsupported claims, no inflated severity, no false positives that would undermine credibility.

Presales also maintains a competitive intelligence knowledge graph that tracks feature releases, pricing changes, and public evaluations of competitors including BitSight, Black Kite, and SecurityScorecard. This intelligence feeds directly into proposal generation, ensuring comparison matrices are always current and evidence-based.

Architecture

Prospect Onboard --> OSINT Scan --> Demo Provisioning --> Live Demo --> Proposal
       |               |              |                 |           |
  Domain Input    Perimeter API    Fly.io Instance    LiveView    PDF/HTML
  Requirements    Tech Stack       Isolated DB        Real Data   ROI Model
  Industry Tag    Security Scan    Seed Data          Scenarios   Comparison
  Contact Map     Competitor DB    Config Apply       Findings    Timeline

Presales follows a three-layer architecture. The Demo Engine manages isolated Fly.io instances with time-limited lifespans, each running a stripped-down platform deployment with prospect-specific configuration. The Intelligence Layer aggregates competitive data from OSINT sources, analyst reports, and public API documentation into a structured knowledge base stored in Prismatic Storage. The Proposal Generator combines templates, prospect intelligence, and competitive positioning into formatted deliverables.

Demo instances are supervised by a DynamicSupervisor with automatic teardown after the configured expiry period, preventing resource leaks. Each instance runs under OTP supervision tree management with Telemetry instrumentation for usage tracking.

Key Modules

Key Features

Demo Environment

The Demo Engine provisions isolated instances that showcase real platform functionality against prospect-specific data:

defmodule PrismaticPresales.DemoEngine do
  @spec provision(keyword()) :: {:ok, DemoInstance.t()} | {:error, term()}
  def provision(opts) do
    prospect = Keyword.fetch!(opts, :prospect)
    scenario = Keyword.get(opts, :scenario, :easm_security_rating)
    duration = Keyword.get(opts, :duration, :days_14)

    with {:ok, scan_results} <- ProspectScanner.scan(prospect),
         {:ok, instance} <- InstanceManager.create(prospect, scenario),
         :ok <- seed_demo_data(instance, scan_results),
         :ok <- apply_scenario_config(instance, scenario),
         :ok <- schedule_teardown(instance, duration) do
      {:ok, %DemoInstance{
        id: instance.id,
        url: instance.url,
        prospect: prospect,
        scenario: scenario,
        findings: length(scan_results.findings),
        expires_at: compute_expiry(duration),
        status: :ready
      }}
    end
  end

  defp schedule_teardown(instance, duration) do
    ttl_ms = duration_to_ms(duration)
    Process.send_after(self(), {:teardown, instance.id}, ttl_ms)
    :ok
  end
end

• On-demand demo instance provisioning with isolated PostgreSQL databases and configuration
• Scenario-based demonstration scripts covering EASM, compliance framework, and risk score rating workflows
• Pre-loaded sample data with realistic entity resolution graphs and security findings
• Customizable LiveView dashboards configured per prospect's industry and needs

Competitive Intelligence

The competitive intelligence system maintains a structured knowledge graph of competitor capabilities:

• Feature comparison matrices against BitSight, Black Kite, SecurityScorecard, and RiskRecon
• Win/loss analysis tracking with structured tagging for loss reasons
• Competitor monitoring from OSINT sources including job postings, patent filings, and press releases
• Pricing intelligence gathering from public RFP responses and analyst reports

Proposal Support

• Automated proposal generation from structured requirements documents
• ROI calculation models based on prospect size, industry, and current tooling
• Technical architecture recommendations tailored to prospect's existing infrastructure
• Implementation timeline estimation with milestone-based delivery plans

Prospect Intelligence

The prospect scanner leverages the platform's own EASM capabilities to provide immediate value during the sales process:

defmodule PrismaticPresales.ProspectScanner do
  @spec scan(String.t()) :: {:ok, ProspectProfile.t()} | {:error, term()}
  def scan(domain) do
    with {:ok, rating} <- PrismaticPerimeter.security_rating(domain),
         {:ok, assets} <- PrismaticPerimeter.discover(domain),
         {:ok, tech_stack} <- detect_technologies(domain),
         {:ok, compliance} <- assess_compliance_posture(domain) do
      {:ok, %ProspectProfile{
        domain: domain,
        security_grade: rating.grade,
        security_score: rating.score,
        assets_discovered: length(assets),
        technologies: tech_stack,
        compliance_gaps: compliance.gaps,
        findings: compile_findings(rating, assets, compliance),
        scanned_at: DateTime.utc_now()
      }}
    end
  end
end

• Automated domain reconnaissance using Prismatic Perimeter scanning capabilities
• Technology stack fingerprinting from public-facing infrastructure analysis
• Vulnerability assessment preview showing real findings for prospect domains
• Industry benchmarking using aggregate security rating data

ROI Modeling

The ROI model calculates projected value based on prospect-specific parameters:

Usage

# Create a demo environment for a prospect
{:ok, demo} = PrismaticPresales.create_demo(
  prospect: "Example Corp",
  scenario: :easm_security_rating,
  duration: :days_14,
  seed_domain: "example.com")
# => %{url: "https://demo-abc123.fly.dev", findings: 47, expires_at: ~U[...]}

# Generate competitive comparison matrix
{:ok, comparison} = PrismaticPresales.compare(
  competitors: [:bitsight, :black_kite, :securityscorecard],
  features: [:asset_discovery, :risk_scoring, :compliance, :api_access],
  format: :html)

# Generate a tailored proposal document
{:ok, proposal} = PrismaticPresales.generate_proposal(
  prospect: "Example Corp",
  requirements: requirements_map,
  format: :pdf)

# Scan prospect domain for immediate value demonstration
{:ok, profile} = PrismaticPresales.prospect_scan("example.com")
# => %{grade: :B, assets: 89, findings: 23, compliance_gaps: [:nis2_article_21]}

# Calculate ROI estimate
{:ok, roi} = PrismaticPresales.estimate_roi(
  prospect_size: :enterprise,
  industry: :financial_services,
  current_tools: [:legacy_scanner, :manual_compliance])
# => %{annual_savings: 285_000, payback_months: 4.2, five_year_roi: 340}

NABLA Compliance

Testing

Demo engine tests verify instance provisioning, data seeding, scenario configuration, and automatic teardown timing. Prospect scanner tests verify domain reconnaissance accuracy, technology fingerprinting, and compliance assessment against known domains. Competitive intelligence tests verify knowledge graph maintenance, comparison matrix accuracy, and update freshness.

Proposal generator tests verify template rendering, ROI calculation accuracy, and format output correctness. Integration tests exercise the full presales pipeline from prospect onboarding through demo provisioning to proposal delivery.

Integration Points

Performance

Telemetry events: [:prismatic, :presales, :demo_created], [:prismatic, :presales, :prospect_scanned], [:prismatic, :presales, :proposal_generated].

Related Resources

• Prismatic Perimeter -- Live EASM scanning for demo environments
• Prismatic CER -- Compliance demonstration capabilities
• Prismatic Narrative -- Report generation for proposal documents
• Prismatic Override -- Demo instance lifecycle management
• Competitor Researcher -- Automated competitive intelligence gathering and analysis
• CER Compliance Commander -- Compliance scenario preparation for demo environments
• Intelligence Synthesis -- Multi-source competitive intelligence fusion for prospect briefings
• Real-Time Monitoring -- Live demo dashboards showcasing real-time security monitoring
• AIAD Compliance -- Demo agent configurations follow AIAD standards for consistency

Connect & Contribute

Created by Tomáš Korcak (korczis) | Open Source under GHL

• GitHub | GitLab | LinkedIn | Contact
• Developer Portal | Architecture | Meet the Creator