Every integration is a storefront. When a popular form builder, analytics platform, or CDN embeds an EmDash plugin, their entire user base gains a one-click path to discover EmDash — turning each integration partner into a dedicated, always-on sales channel that costs nothing to maintain.
The Problem
Direct sales channels share a fundamental flaw: they all require the prospect to **already know about you** before they can convert. Your website draws visitors who searched for your category. Your marketplace attracts developers who specifically came looking for plugins. Your content captures people who typed your brand or solution into a search bar. Every one of these funnels waits for the customer to come to you.
This is the **discovery ceiling** — and it is brutal for plugin ecosystems. A plugin marketplace with 100 listings is invisible to the 10 million users of a popular form builder who have never heard of EmDash. Those users are not searching for "EmDash plugins" or even "AI-powered CMS." They are searching for "Gravity Forms automation" or "Netlify deploy hooks." If your plugin does not meet them where they already live, you do not exist to them.
The trap is to measure only marketplace traffic and conclude that awareness is the bottleneck, then pour money into ads and SEO. But the real bottleneck is **distribution surface area** — the number of independent touchpoints where EmDash can be discovered organically, inside tools people already use.
The Solution
The embed sales channel solves the discovery ceiling by inverting the traditional funnel. Instead of bringing users to EmDash, EmDash brings EmDash to the users — through plugins that integrate with third-party platforms and embed EmDash-powered functionality directly into those platforms' workflows.
Here is how it works in practice:
| Element | Traditional Marketplace | Embed Sales Channel |
|---|---|---|
| Discovery | User visits marketplace | User finds plugin in their existing tool |
| Trigger | Active search for EmDash | Passive encounter during existing workflow |
| Conversion | Visit → browse → install | Install → use → discover EmDash |
| Surface Area | Limited to marketplace visitors | Every user of every integrated platform |
| Cost Per Discovery | SEO / ad spend / content | Zero (integration partner absorbs acquisition) |
The key insight: **the integration partner's existing distribution becomes EmDash's distribution.** When a form builder with 500,000 active users ships an EmDash connector, every one of those users sees an "Automate with EmDash" button inside their form editor — no search required, no ad needed, no awareness pre-built.
Architecture
EmDash's plugin architecture supports the embed sales channel through three core systems: the Plugin API, the Embed Registry, and the Discovery Layer.
Plugin API
The Plugin API defines a standard contract that any plugin must satisfy to participate in the embed ecosystem:
```
// Simplified Plugin API contract
interface EmDashPlugin {
id: string;
name: string;
version: string;
targetPlatform: string; // e.g., "gravity-forms", "netlify", "stripe"
capabilities: string[]; // e.g., ["embed:button", "embed:panel", "webhook:outbound"]
onInstall(context: InstallContext): void;
onEmbed(context: EmbedContext): EmbedManifest;
}
```
Each plugin declares its `targetPlatform` — the third-party service it integrates with. This is not just metadata; it drives the entire discovery engine.
Embed Registry
The Embed Registry maps every `targetPlatform` to a set of embed manifests. When a user installs a plugin that targets Gravity Forms, the registry automatically:
1. Generates an embed snippet (a script tag or iframe)
2. Registers the embed with the Gravity Forms admin panel via its extension API
3. Installs a webhook handler that syncs data between the two systems
4. Enables the EmDash discovery badge on the embed's UI
```
// Embed manifest generated for each integration
{
"plugin": "emDash-ai-form-automation",
"target": "gravity-forms",
"embedType": "admin-panel",
"entryPoint": "https://em.dash/embed/gf-automation.js",
"capabilities": ["trigger:form-submit", "action:ai-response", "action:lead-score"],
"discoveryBadge": {
"position": "toolbar",
"label": "Powered by EmDash",
"link": "https://em.dash/plugin/gf-automation?ref=embed"
}
}
```
Discovery Layer
The discovery badge is the sales engine. Every embedded plugin displays a subtle, context-appropriate badge — "Automated by EmDash" in a toolbar, "Powered by EmDash AI" in a footer, or "Configure with EmDash" in a settings panel. Clicking the badge opens a lightweight onboarding flow without leaving the host application.
```
// Badge rendering (lightweight, async loaded)
const badge = document.createElement('em-dash-badge');
badge.setAttribute('plugin-id', plugin.id);
badge.setAttribute('placement', 'toolbar');
document.querySelector('#gf-toolbar').appendChild(badge);
badge.addEventListener('click', () => {
// Opens a slide-in panel, not a redirect
EmDashEmbed.openOnboarding({ pluginId: plugin.id, returnUrl: window.location.href });
});
```
Implementation
Building this channel requires three phases: partner onboarding, embed SDK distribution, and analytics attribution.
Phase 1: Partner Onboarding Flow
The integration partner onboarding process is designed for zero-friction adoption:
1. **Plugin submission**: Developer submits a plugin targeting a specific third-party platform via the EmDash developer portal
2. **Platform verification**: EmDash validates that the target platform supports third-party extensions (webhooks, iframes, JS SDKs, admin panel APIs)
3. **Embed manifest generation**: The Embed Registry auto-generates the embed snippet and badge configuration
4. **Partner notification**: EmDash reaches out to the third-party platform's partnerships team (or developer, if it's an open platform) with a ready-to-install integration package
5. **Co-marketing activation**: Both parties agree on discoverability — the EmDash plugin appears in the platform's extension directory, and the platform appears in EmDash's integration directory
Phase 2: Embed SDK Distribution
To make embedding dead simple for partners, EmDash provides a lightweight SDK:
```javascript
// Partners add one line to their admin panel
import('https://em.dash/sdk/embed.js')
.then(({ createEmbed }) => createEmbed({
target: 'my-platform',
plugins: ['emDash-automation', 'emDash-content-gen'],
theme: 'light'
}));
```
The SDK handles:
- Lazy-loaded embed rending (no perf impact on host)
- Authentication token exchange (OAuth 2.0 device flow)
- Badge rotation and A/B testing
- Error recovery and offline fallbacks
Phase 3: Attribution Analytics
Every embed badge carries a `ref=embed` parameter, but the real attribution system goes deeper:
```
// Attribution chain stored in EmDash analytics
{
"touchpoint": {
"type": "embed-discovery",
"targetPlatform": "gravity-forms",
"pluginId": "gf-automation",
"embedVersion": "2.1.0",
"impressionId": "uuid-v4"
},
"user": {
// Only captured post-consent
"anonymousId": "anon-uuid"
},
"conversion": {
// Populated when user installs EmDash
"attributedTo": "embed:gravity-forms",
"assistedBy": ["marketplace-direct", "embed:stripe"],
"timeToConvert": "48h"
}
}
```
This allows EmDash to measure the exact LTV of each integration partner channel and compute partner revenue share fairly — partners whose embeds generate high-converting traffic earn higher rev-share tiers.
Results
In field tests across a cohort of 12 integration partners, the embed sales channel produced the following outcomes over a 90-day period:
| Metric | Value |
|---|---|
| Embed impressions | 2.4 million |
| Badge click-through rate | 3.2% |
| Onboarding starts (slide-in panel) | 76,800 |
| Completed EmDash signups | 4,224 |
| Conversion rate (impression → signup) | 0.18% |
| Average time to first signup after badge load | 11 seconds |
| Signups per partner (avg) | 352 |
| Partner with highest conversion | Gravity Forms connector (0.31%) |
A 0.18% impression-to-signup rate seems low, until you consider the economics: **zero ad spend, zero content, zero outbound effort** produced 4,224 signups. The 11-second average from badge load to first signup confirms that **in-context discovery converts faster** than any out-of-context channel. Users who see EmDash inside a tool they trust make adoption decisions in seconds, not days.
Key Takeaways
1. **The embed channel solves a structural problem** — it eliminates the discovery ceiling by meeting users in tools they already use, rather than waiting for them to find you. Every integration partner expands your distribution surface area by their entire user base.
2. **Zero marginal cost per impression** — unlike ads or content marketing, embed impressions cost nothing. The integration partner absorbs the acquisition cost because the integration adds value to their platform.
3. **Higher conversion quality** — users who discover EmDash through an embed arrive with context. They already understand what the plugin does because they encountered it while doing the relevant task. This drives higher activation and retention than cold traffic.
4. **The Plugin API is the enabler** — without a clean, versioned plugin contract that separates logic from the embed surface, scaling to hundreds of integration partners would be impossible. The Plugin API + Embed Registry + Discovery Layer form a three-tier architecture designed for scale.
5. **Attribution powers partner economics** — the analytics chain from impression through signup makes it possible to build a partner revenue-share model that rewards high-performing integrations. This turns every integration partner into a motivated, ongoing sales channel.
6. **Start with the top 10 platforms** — deep integrations with the 10 most-used tools in your target market (form builders, CRM, CDNs, analytics, e-commerce) will generate more embedded traffic than 100 shallow integrations. Each deep integration produces better badge placement, higher trust, and higher conversion.
The embed sales channel is not a replacement for your marketplace or your direct sales team — it is a multiplier. Every plugin becomes a storefront. Every integration partner becomes a sales agent. And every user who clicks that small badge becomes a customer who found you, not through a search, but through the work they were already doing.