Skip to content

DEMO_PRESENTATION_SCRIPT.md

Latest commit

 

History

History
590 lines (477 loc) · 25.7 KB

DEMO_PRESENTATION_SCRIPT.md

File metadata and controls

590 lines (477 loc) · 25.7 KB

QuickApiMapper Demo Presentation Script

Complete presentation script for live demos and video recordings with timing, talking points, and audience engagement strategies.

Table of Contents

Presentation Overview

Target Audience

  • Primary: Technical decision makers, architects, integration specialists
  • Secondary: Developers, DevOps engineers, product managers
  • Level: Intermediate to advanced technical knowledge

Presentation Goals

  1. Demonstrate QuickApiMapper's core value proposition: eliminating custom integration code
  2. Show real-world applicability through e-commerce order fulfillment scenario
  3. Highlight production-ready features: performance, monitoring, extensibility
  4. Generate interest in deeper evaluation or proof-of-concept

Time Allocation (Total: 20 minutes)

Section Duration Cumulative
Introduction 2 min 0:02
Problem Statement 2 min 0:04
Architecture Overview 2 min 0:06
Configuration Walkthrough 4 min 0:10
Live Transformation Demo 5 min 0:15
Advanced Features 3 min 0:18
Q&A 2 min 0:20

Introduction Script

Opening (30 seconds)

[Display title slide: "QuickApiMapper: Zero-Code Integration Platform"]

Script:

"Good [morning/afternoon], everyone. Thank you for joining today's demonstration of QuickApiMapper. My name is [Your Name], and over the next 20 minutes, I'm going to show you how QuickApiMapper eliminates the need for custom integration code when connecting modern systems with legacy infrastructure.

By the end of this demo, you'll see a complete transformation from a JSON REST API to a SOAP service—configured entirely through a visual interface, with zero code deployment."

Key Message: Set expectation for "zero code" and "visual configuration"

Slide: Simple title slide with QuickApiMapper logo and tagline

Agenda Overview (30 seconds)

[Display agenda slide]

Script:

"Here's what we'll cover:

  1. The integration challenge—why this matters
  2. A quick architecture overview
  3. Live demo: JSON to SOAP transformation
  4. Advanced capabilities
  5. Your questions

Feel free to ask questions as we go, but I'll also reserve time at the end for deeper discussion."

Key Message: Clear roadmap, invites engagement

Slide: Bullet-point agenda

Engagement Check (30 seconds)

Script:

"Quick poll: How many of you currently maintain custom integration code to connect different systems? [Pause for hands/responses]

And how many of those integrations involve SOAP or other legacy protocols? [Pause]

Great—so this is very relevant for most of you. Let's dive in."

Key Message: Establish relevance, build connection with audience

Tip: In virtual presentations, use chat or poll features instead of hands

Main Demo Script

Part 1: Problem Statement (2 minutes)

[Display problem slide: Side-by-side of modern vs. legacy systems]

Script:

"Let me set the stage with a real-world scenario that many of you face.

[Point to left side] On this side, we have a modern e-commerce platform. It exposes a clean JSON REST API for order management. State-of-the-art, well-documented, easy to work with.

[Point to right side] On this side, we have a legacy warehouse management system. It only speaks SOAP. Circa 2008. No one wants to touch it, but it works, and replacing it would cost millions.

The challenge: These two systems need to talk to each other. Every hour, potentially hundreds of orders need to flow from the e-commerce platform to the warehouse.

[Display traditional approach slide] The traditional approach?

  • Write custom transformation code
  • Deploy and maintain that code
  • Handle errors, retries, logging
  • Update code every time fields change
  • Repeat for every integration

This is what most companies do. It works, but it's slow, brittle, and expensive.

[Display QuickApiMapper approach slide] QuickApiMapper takes a different approach:

  • Configure once through a visual interface
  • No code deployment
  • Update mappings in real-time
  • Production-ready observability built-in
  • Same platform for all integrations

Let me show you how this works."

What to Show:

  • Slide 1: Two system diagrams (modern JSON API vs legacy SOAP)
  • Slide 2: Traditional approach (code snippets, deployment pipeline, complexity)
  • Slide 3: QuickApiMapper approach (simple config diagram, dashboard screenshot)

Key Messages:

  • Real-world problem everyone faces
  • Traditional approach is painful
  • QuickApiMapper offers a better way

Timing Checkpoint: Should be at 4 minutes cumulative

Part 2: Architecture Overview (2 minutes)

[Display architecture diagram from ARCHITECTURE_DEMO.md]

Script:

"Here's the architecture at a high level. Don't worry—it's simpler than it looks.

[Point to middle] At the center is QuickApiMapper Web—the transformation engine. This is where the magic happens.

[Point to left] On the left, we have our sources—the systems sending data. In today's demo, that's our e-commerce JSON API. But it could be message queues, gRPC services, webhooks—anything.

[Point to right] On the right, our destinations—the systems receiving data. Today, that's our SOAP warehouse service. But again, it could be anything—databases, SaaS platforms, other APIs.

[Point to bottom] Supporting this, we have:

  • PostgreSQL for storing integration configurations
  • Redis for caching
  • RabbitMQ for async message processing

[Point to top] And critically, we have the Designer Dashboard—a web UI where you configure everything. No code. No deployments.

All of this runs in containers, orchestrated by .NET Aspire, which gives us observability, health checks, and service discovery out of the box.

Now, let's see it in action."

What to Show:

  • Architecture diagram (from ARCHITECTURE_DEMO.md)
  • Highlight components as you describe them
  • Keep it high-level—details come later

Key Messages:

  • Clear separation of concerns
  • Flexible sources and destinations
  • Visual configuration via Dashboard
  • Production-grade infrastructure

Timing Checkpoint: Should be at 6 minutes cumulative

Part 3: Configuration Walkthrough (4 minutes)

[Switch to live demo—open Designer Dashboard at https://localhost:7002]

Script:

"Alright, now we're live. This is the QuickApiMapper Designer Dashboard.

[Show integrations list] I've already seeded three demo integrations. Let's focus on this one: 'Demo: JSON to SOAP Order Processing.'

[Click on the integration] When I click on it, we see the complete configuration.

[Scroll through overview] At the top, we have:

  • Name: A descriptive name for this integration
  • Endpoint: The API route that triggers this transformation—/api/demo/fulfillment/submit
  • Source Type: JSON—what we receive
  • Destination Type: SOAP—what we send
  • Destination URL: Where the transformed data goes—our warehouse SOAP service
  • Message Capture: Enabled—every transformation is logged for audit and debugging

Simple configuration. But the real power is in the field mappings.

[Scroll to field mappings section] Here we have 16 field mappings. Each one says:

  • Take this field from the source (using JSONPath)
  • Put it here in the destination (using XPath)
  • Optionally apply transformers to modify the data

Let me show you a few examples.

[Point to email mapping] This one maps the customer email. Source is $.customerEmail from our JSON. Destination is /CustomerInfo/ContactEmail in the SOAP envelope. And we apply a ToLower transformer to normalize the email to lowercase.

[Point to SKU mapping] This one maps product SKUs. Source is $.items[*].sku—note the [*], which means 'all items in the array.' Destination is /LineItems/Item/SKU. And we apply ToUpper to standardize SKUs to uppercase.

[Point to priority mapping] This one's interesting. Source is $.priority, destination is /PriorityCode. But the transformer is MapValue, which does code mapping:

  • STANDARD becomes STD
  • EXPRESS becomes EXP
  • OVERNIGHT becomes OVN

This is how we handle differences in terminology between systems.

[Scroll through remaining mappings quickly] The rest are similar—customer name, order ID, shipping address fields, item details. All configured here. No code.

Now, what happens when we send an order through this integration? Let's find out."

What to Show:

  • Designer Dashboard homepage
  • Integrations list
  • One integration's detailed configuration
  • Highlight 3-4 specific field mappings
  • Show transformers

Key Messages:

  • Visual configuration interface
  • JSONPath and XPath for flexible mapping
  • Transformers handle business logic
  • Easy to understand and modify

Timing Checkpoint: Should be at 10 minutes cumulative

Part 4: Live Transformation Demo (5 minutes)

[Switch to terminal or Postman]

Script:

"Now for the moment of truth. I'm going to submit a JSON order and show you the transformation in real-time.

[Display sample JSON order] Here's our order. It's a typical e-commerce order:

  • Order ID: ORD-DEMO-001
  • Customer: Jane Anderson
  • Email: JANE.ANDERSON@EXAMPLE.COM—note it's all caps
  • One item: a MacBook Pro, SKU laptop-macbook-pro—lowercase
  • Shipping to San Francisco
  • Priority: EXPRESS

Watch what happens when I send this to QuickApiMapper.

[Execute the POST request]

[Show response] Success. We got back a confirmation from the warehouse system:

  • Confirmation number: WH-20260111-A1B2C3D4
  • Status: PENDING
  • Estimated ship date: three days from now

QuickApiMapper transformed our JSON to SOAP, forwarded it to the warehouse, and returned the response. All in about 150 milliseconds.

But let's see the details. Let me switch to the Dashboard.

[Switch to Designer Dashboard, navigate to Message History]

[Click on the latest message] Here's our transformation, captured in real-time.

[Show Input tab] On the Input tab, we see the original JSON we sent. Customer email is in all caps: JANE.ANDERSON@EXAMPLE.COM. SKU is lowercase: laptop-macbook-pro. Priority is the word EXPRESS.

[Show Output tab] On the Output tab, we see the SOAP envelope that was sent to the warehouse. Let me highlight the transformations:

[Point to email in SOAP] Email is now lowercase: jane.anderson@example.com. That's our ToLower transformer at work.

[Point to SKU in SOAP] SKU is now uppercase: LAPTOP-MACBOOK-PRO. That's the ToUpper transformer.

[Point to priority code in SOAP] And priority is now EXP—the code the legacy system expects. That's our MapValue transformer.

[Scroll to show full SOAP envelope] The entire structure has been transformed. Flat JSON fields became nested XML elements. Field names changed from camelCase to the warehouse's expected names. The SOAP envelope was automatically constructed with the correct namespaces and headers.

All of this—configured once, runs automatically, captures everything for audit.

Let me send another order with a different priority to show the flexibility.

[Submit overnight order]

[Show in Dashboard] There it is. Priority was OVERNIGHT, and in the SOAP output, it's now OVN. Same configuration, different mapping applied.

And look at the processing time: 120 milliseconds. Production-ready performance."

What to Show:

  1. Sample JSON order payload (pretty-printed)
  2. cURL or Postman POST request execution
  3. Successful HTTP response
  4. Designer Dashboard message list
  5. Message detail view with Input and Output tabs
  6. Highlight specific transformations (email, SKU, priority)
  7. Second order submission with different priority

Key Messages:

  • Fast, real-time transformation
  • Exact transformations as configured
  • Full audit trail
  • Production-ready performance
  • Flexibility for different scenarios

Timing Checkpoint: Should be at 15 minutes cumulative

Part 5: Advanced Features (3 minutes)

[Stay in Designer Dashboard]

Script:

"What I've shown you is the core transformation capability. But QuickApiMapper has several advanced features worth highlighting.

[Navigate to Statistics or Dashboard view] First, observability. Every transformation is tracked. Here we can see:

  • Total messages processed
  • Success rate—right now, 100%
  • Average processing time—under 200 milliseconds
  • Breakdown by integration

This is all built-in. No additional configuration needed.

[Open RabbitMQ management UI or show config] Second, message queue integration. We have the same configuration available for asynchronous processing via RabbitMQ. Publish a message to a queue with a routing key, and QuickApiMapper automatically consumes, transforms, and forwards it—using the exact same configuration we saw earlier.

Same mappings, same transformers, different trigger mechanism. This is huge for batch processing or decoupling systems.

[Show or describe] Third, extensibility. Those transformers we saw—ToLower, ToUpper, MapValue—they're built-in. But you can drop in custom transformers as DLLs. Implement the ITransformer interface, drop the DLL into a folder, and QuickApiMapper loads it at startup. No recompilation. No deployment pipeline.

For example, if you need complex business logic—currency conversion, date formatting, custom validation—write a transformer once, reuse it across all integrations.

[Show or describe] Fourth, bi-directional transformations. We showed JSON to SOAP. But QuickApiMapper also does SOAP to JSON, JSON to JSON, XML to XML—any combination. You can build a complete integration layer with one platform.

[Show Management API or mention] And finally, everything is API-driven. That Designer Dashboard is built on the Management API. So you can script integration creation, automate deployments, integrate QuickApiMapper configuration into your CI/CD pipelines—whatever you need.

In summary:

  • Visual configuration—no code
  • Sub-200ms performance—production-ready
  • Full observability—audit trails, monitoring, stats
  • Extensible—custom transformers, API-driven
  • Unified platform—HTTP, message queues, multiple protocols

That's QuickApiMapper. Let's open up for questions."

What to Show:

  • Dashboard statistics/metrics
  • RabbitMQ management UI (optional)
  • Mention or show transformer code structure (optional)
  • Mention or show Management API (optional)

Key Messages:

  • More than just transformation—full platform
  • Production-grade observability
  • Extensibility without complexity
  • Unified approach to integration

Timing Checkpoint: Should be at 18 minutes cumulative

Q&A Preparation

Common Questions and Answers

Q: "What if the destination service is down? How do you handle retries?"

Answer:

"Great question. QuickApiMapper has configurable retry logic via the Behavior Pipeline. You can set up an HTTP retry behavior that automatically retries failed requests with exponential backoff. For message queue integrations, failed messages go to a dead-letter queue where they can be inspected and re-queued. All of this is configurable per integration, so you can have different retry strategies for different systems."

Follow-Up Points:

  • Show or mention Behavior Pipeline configuration
  • Highlight dead-letter queue in RabbitMQ
  • Mention timeout configuration

Q: "How does this handle authentication to the destination systems?"

Answer:

"Another great question. QuickApiMapper includes an Authentication Behavior that supports OAuth2, JWT bearer tokens, and API keys. You configure the auth endpoint, client credentials, and token caching strategy in the integration config. QuickApiMapper automatically acquires tokens, caches them, and refreshes them before expiry. For SOAP services with WS-Security, you can configure username/password in the SOAP header fields."

Follow-Up Points:

  • Show static values for credentials (mention secure storage with Key Vault in production)
  • Highlight SOAP header configuration
  • Mention token caching with Redis

Q: "What about performance at scale? Can this handle thousands of messages per second?"

Answer:

"QuickApiMapper is designed for production scale. The transformation engine is stateless, so you can scale horizontally by adding more instances behind a load balancer. For message queue scenarios, you can run multiple workers consuming from the same queue for parallel processing. We have customers processing millions of messages daily with sub-200ms latency. Message capture can be configured to async mode to avoid impacting throughput."

Follow-Up Points:

  • Mention horizontal scaling
  • Highlight async message capture
  • Reference caching with Redis for configuration
  • Discuss load testing results

Q: "How do we migrate existing integrations to QuickApiMapper?"

Answer:

"We provide a migration assistant tool that can analyze existing integration code—whether it's custom C#, BizTalk, or other platforms—and generate QuickApiMapper configurations. It won't be perfect for complex scenarios, but it gives you a 70-80% head start. From there, you refine the mappings in the Designer Dashboard. I've seen migrations completed in days instead of months."

Follow-Up Points:

  • Mention migration tool location
  • Suggest a pilot integration approach
  • Offer to provide migration assessment

Q: "What happens if we need to change a field mapping in production?"

Answer:

"That's one of QuickApiMapper's biggest advantages. You update the field mapping in the Designer Dashboard or via the Management API. The change is immediate—no code deployment, no downtime. QuickApiMapper reloads the configuration from the database on the next request. We recommend testing changes in a staging environment first, but the actual production update is instant."

Follow-Up Points:

  • Highlight immediate config reload
  • Mention versioning strategy (best practice)
  • Suggest staging environment testing

Q: "Can QuickApiMapper transform complex nested JSON or XML structures?"

Answer:

"Absolutely. JSONPath and XPath are very powerful. You can navigate deeply nested structures, iterate over arrays, even apply conditional logic with transformer arguments. For very complex scenarios—like flattening a deeply nested structure or aggregating data from multiple sources—you can write a custom transformer that encapsulates that logic. Once written, it's reusable across all integrations."

Follow-Up Points:

  • Show an example of complex JSONPath (e.g., $.items[*].variants[*].sku)
  • Mention array handling
  • Reference custom transformer extensibility

Q: "Is there version control for integration configurations?"

Answer:

"The configurations are stored in PostgreSQL, so you can back them up and restore them as needed. For version control integration, you can export configurations to JSON via the Management API, commit those to Git, and deploy them as part of your CI/CD pipeline. We're also working on built-in versioning with rollback capability—that's on the roadmap."

Follow-Up Points:

  • Mention export/import via Management API
  • Suggest Git-based workflow
  • Highlight roadmap item for built-in versioning

Q: "What's the licensing model?"

Answer:

"QuickApiMapper is open-source under the MIT license, so you can use it freely. For enterprise support, managed hosting, and additional features like advanced analytics and centralized management across multiple instances, we offer commercial plans. But the core platform is free and will always be free."

Follow-Up Points:

  • Clarify MIT license
  • Mention enterprise support options
  • Offer to connect with sales/support team

Handling Difficult Questions

If you don't know the answer:

"That's a great question, and I want to give you an accurate answer. Let me take that offline and follow up with you within 24 hours. Can I get your email?"

If the question is off-topic:

"That's an interesting topic, but I want to respect everyone's time. Can we discuss that after the demo? I'm happy to stay on a bit longer."

If the question is too detailed:

"That's getting into the weeds a bit. How about we schedule a technical deep-dive session where we can cover that in detail?"

Conclusion Script

Summary and Call-to-Action (2 minutes)

[Return to summary slide]

Script:

"Alright, let's wrap up. In the last 20 minutes, you've seen:

[Recap key points]

  1. A real-world integration challenge—connecting modern JSON APIs with legacy SOAP services
  2. How QuickApiMapper solves this with visual configuration—no custom code
  3. Live transformation of an e-commerce order with multiple field mappings and transformers
  4. Production-grade features—observability, performance, message queues, extensibility

The key takeaway: QuickApiMapper eliminates the custom code treadmill for integrations. Configure once, run forever, update instantly.

[Display next steps slide]

Here's what I recommend as next steps:

  1. Try it yourself: The entire demo you just saw is available on GitHub. Clone the repo, run dotnet run, and you'll have it up in 5 minutes.

  2. Read the docs: We have comprehensive documentation—demo guide, API samples, architecture diagrams. I'll share the links in the chat/email.

  3. Schedule a deep-dive: If you have a specific integration challenge, let's schedule a 1-hour technical session. We can walk through your use case and design an integration live.

  4. Join the community: We have an active community on GitHub Discussions. Ask questions, share your integrations, contribute ideas.

[Display contact slide]

I'll stay on for another 10 minutes if anyone wants to discuss further. You can also reach me at [your-email@example.com].

Thank you for your time today. I hope you found this valuable."

What to Show:

  • Summary slide (bullet points of key takeaways)
  • Next steps slide (actionable items)
  • Contact slide (email, GitHub, Slack/Discord link)

Key Messages:

  • Reinforce value proposition
  • Provide clear next steps
  • Make it easy to follow up

Timing Checkpoint: Should be at 20 minutes cumulative

Video Recording Guide

Pre-Production Checklist

Technical Setup:

  • Record in 1920x1080 resolution minimum
  • Use external microphone for clear audio
  • Close unnecessary applications to avoid notifications
  • Test screen recording software (OBS, Camtasia, etc.)
  • Prepare all terminal commands in advance (script or notes file)

Environment Setup:

  • Start all services with dotnet run in AppHost
  • Verify all services are healthy in Aspire Dashboard
  • Clear message history or use fresh database
  • Increase terminal font size for readability
  • Set browser zoom to 100% or 110%
  • Use incognito/private mode to avoid autofill/suggestions

Content Preparation:

  • Practice the full demo 2-3 times
  • Time each section to ensure 15-20 minute target
  • Prepare on-screen annotations/highlights (if using)
  • Create slide deck (title, problem, solution, architecture, next steps)
  • Save sample JSON payloads as separate files for easy reference

Recording Structure

Opening (20 seconds):

  • Title screen with QuickApiMapper logo
  • Your name and title
  • Date (optional)
  • Brief tagline: "Zero-Code Integration Platform Demo"

Main Content (15-18 minutes):

  • Follow the Main Demo Script (sections 1-5)
  • Use on-screen text overlays for key points
  • Zoom into UI elements when showing configuration details
  • Slow down mouse movements for clarity
  • Pause briefly between major sections for editing cuts

Closing (30 seconds):

  • Summary of key points
  • Next steps (try it, read docs, contact)
  • Display GitHub link and documentation link
  • End screen with contact information

Editing Tips

Cuts and Pacing:

  • Cut out long pauses, "um"s, and mistakes
  • Add fade transitions between major sections
  • Speed up (1.25x) any slow UI loading or navigation
  • Keep total runtime under 18 minutes for maximum retention

Visual Enhancements:

  • Add zoom-in effects when showing small UI elements
  • Highlight cursor or use spotlight effect
  • Add arrows or callouts to point to specific fields
  • Use on-screen text for key terms (JSONPath, XPath, SOAP)

Audio Enhancements:

  • Normalize audio levels
  • Remove background noise
  • Add subtle background music (low volume, non-distracting)
  • Add sound effects for key moments (success, error)

Publishing Checklist

Video File:

  • Export in 1080p MP4 (H.264 codec)
  • File size under 500MB for easy sharing
  • Test playback on multiple devices

Video Platforms:

  • YouTube (public or unlisted)
  • Company website/docs
  • GitHub repository README
  • LinkedIn/social media (shorter version)

Metadata:

  • Descriptive title: "QuickApiMapper Demo: JSON to SOAP Transformation in 15 Minutes"
  • Detailed description with timestamps and links
  • Tags: integration, API, SOAP, JSON, transformation, microservices
  • Thumbnail: High-quality screenshot with title overlay
  • Closed captions/subtitles (auto-generated or manual)

Promotion:

  • Share on social media
  • Post in relevant communities (Reddit, Discord, Slack)
  • Include in email newsletters
  • Add to documentation website

Document Version: 1.0 Last Updated: 2026-01-11 Related Documents: DEMO_GUIDE.md, API_SAMPLES.md, DEMO_FAQ.md