KumoMTA managed service · Apache 2 license · Rust + Lua · cloud-native · From $1,490/mo

Apache 2 license. Rust async core. Lua policies that hot-reload in 300 seconds. We run it for you.

Continuous managed operation of KumoMTA infrastructure for greenfield deployments and teams currently on PowerMTA where the recurring Bird license cost has reached the threshold where Apache 2 economics justify migration. Daily covers init.lua policy authoring, traffic shaping per ISP through kumo.on event hooks aligned to Gmail, Yahoo, Microsoft, Apple throttle policies, tenant throttle calibration via get_queue_config callbacks for native multi-tenancy isolation, sysctl tuning bundled with KumoMTA recommended values (vm.max_map_count, file-max, somaxconn), Prometheus metrics integration at /metrics endpoint scraped every 15 seconds, Loki log shipping for structured JSON, hot-reload verification on every Lua policy commit. Weekly traffic shaping calibration. Tenant throttle review. IP rotation balance via egress_pool reassignment. Monthly KumoMTA version upgrade evaluation against KumoCorp release notes, capacity planning, structured SLA report. Plus PowerMTA-to-KumoMTA migration scope when applicable: virtual-mta to egress_pool translation, bounce_pattern to bounce_classifier rewrite, retry-interval to traffic shaping rules. 6 PowerMTA-to-KumoMTA migrations completed between 2024 and Q1 2026. From $1,490 per month single-node up to $7,890 per month enterprise multi-region cluster.

License modelApache 2no usage caps
Hot-reload window300sor 1024 execs
Migrations completed6PMTA→Kumo since 2024
Sweet spot volume500K-50Mmonthly messages
Architecture · what makes KumoMTA structurally different from PowerMTA

Four pillars that explain every practical tradeoff.

KumoMTA was built from scratch in Rust by Wez Furlong, who spent nearly a decade as Chief Architect at Message Systems where he designed Momentum, one of PowerMTA's only real competitors. Wez brought everything learned from building commercial MTAs. He started fresh with modern tooling. No legacy constraints. No licensing fees. Four architectural pillars matter for the operational reality of running KumoMTA in production, and understanding these pillars explains nearly every practical tradeoff you will face versus PowerMTA, MailerQ, or Halon.

PILLAR 1 · LANGUAGE

Rust core, Lua policies

The performance-critical engine runs in Rust with async I/O patterns calibrated for many concurrent SMTP connections. The configuration and policy layer runs in Lua via MLua bindings with context pooling. The engine handles bytes and protocol; the policy describes business logic. Operational implication: MTA upgrades land without touching policy, policy changes land without touching engine binary.

Tech: Rust async runtime · MLua Rust-Lua bridge · context pooling · structured JSON logging · validate-shaping CI binary
PILLAR 2 · CONFIGURATION AS CODE

Lua scripts hot-reload in 300 seconds

Policy lives at /opt/kumomta/etc/policy/init.lua and refreshes every 300 seconds or 1024 executions, whichever comes first, without operational restart. Includes and require directives work like programming language imports rather than configuration concatenation. Validate-shaping binary runs as a CI check on every commit before deployment, catching errors before production. Rollback is git revert plus 300-second wait.

Hot-reload window: 300s timer or 1024 invocations · Path: /opt/kumomta/etc/policy/init.lua · Modules: /opt/kumomta/share · CI: validate-shaping
PILLAR 3 · MULTI-TENANT ISOLATION

Per-tenant queue isolation native

Tenant isolation is first-class through the kumo.on('get_queue_config') callback that receives domain plus tenant plus campaign plus routing_domain and returns the egress_pool assignment. Each tenant's traffic flows through its own queue. One tenant's reputation incident does not touch the others. Compared to PowerMTA's virtual-mta approach, which works but requires manual coordination, KumoMTA's tenant model was designed for multi-tenant ESP architecture from day zero.

Hooks: kumo.on('get_queue_config') · Returns: egress_pool assignment · Isolation: per-tenant queues independent
PILLAR 4 · CLOUD-NATIVE POSTURE

Linux-only, K8s-ready, Prometheus-default

No Windows Server support upstream and no apologetic posture about it. Linux-only because the engineering team shipped what cloud-native deployments actually need rather than maintaining 2003-era cross-platform commitments. Prometheus metrics endpoint exposed by default on /metrics. Structured JSON logs stream to Loki or ELK without parsing rules. Kubernetes manifests work natively because the engine was designed for containerized deployment. Sysctl tuning bundled with recommended starting values during install.

OS: RHEL 9 / Rocky 9 / AlmaLinux 9 / Ubuntu 22.04 / Ubuntu 24.04 / Debian 12 · Metrics: /metrics scraped every 15s · Logs: structured JSON · Sysctl: bundled defaults
2023initial release
KumoMTA launched end of 2023, mature production cycle 2024-2026, current 28 months of accumulated production exposure
$0license cost recurring
Apache 2.0 license eliminates the $18K-$210K annual Bird license fee that PowerMTA carries at production scale (3-20 nodes)
300shot-reload window
Lua policy refreshes deterministically without operational restart, 300 seconds or 1024 invocations whichever comes first
6migrations completed
PowerMTA-to-KumoMTA production migrations completed by EMP between 2024 and Q1 2026, plus 4 greenfield deployments
License savings calculator · interactive · estimates based on Bird pricing patterns 2026

How much does KumoMTA actually save? Pick your node count.

Bird does not publish PowerMTA license pricing on their website (quote-based, volume-driven). The estimates below reflect typical 2026 pricing patterns reported across the industry and our own quoted contracts. Pick your current PowerMTA node count and see the year-one and year-three economics. Note: the figures are honest estimates not contractual guarantees, and your actual Bird quote may vary based on instance count, environment posture, and message volume.

Bird license estimate based on 2026 pricing patterns: ~$5K-$8K per node annually depending on volume tier and environment count. KumoMTA managed pricing: Single-node $1,490/mo, Cluster $3,990/mo (2-6 nodes), Enterprise $7,890/mo (7-20 nodes). Migration scope: $14K-$28K one-time depending on configuration depth. ROI calculations assume current Bird annual cost continues at flat rate (it typically rises 8-15% per renewal, which would shorten the payback window).

Migration timeline · 4 phases · 7 weeks · rollback at every step

PowerMTA to KumoMTA migration. Shadow deployment, progressive cutover, real rollback.

Migration is a separate scope from managed service, runs $14,000 to $28,000 depending on configuration depth and multi-tenancy complexity. Four phases over approximately 7 weeks. Shadow deployment runs KumoMTA in parallel with production PowerMTA on a canary subdomain that does not affect main domain reputation. Progressive cutover from 10 to 100 percent traffic over 14 days with rollback capability at each step. We have completed 6 PowerMTA-to-KumoMTA migrations between 2024 and Q1 2026 plus 3 reverse migrations the other direction when teams determined Lua complexity exceeded their license savings. The reverse capability is real and we discuss it openly during planning.

4-phase migration · 7 weeks · canary-first cutover

PHASE 1 · WEEKS 1-2

Configuration translation

PowerMTA virtual-mta blocks become KumoMTA egress_pool definitions. PowerMTA bounce_pattern blocks become bounce_classifier rules in Lua. Retry-interval ladders translate into traffic shaping rules per ISP. Accounting log format gets compatibility layer so downstream billing systems do not break.

PHASE 2 · WEEKS 3-4

Shadow deployment

KumoMTA runs in parallel with PowerMTA, receiving 5-10 percent of production traffic on a canary subdomain. Metrics tracked: throughput parity, latency parity, deferral parity, bounce categorization parity. Main domain reputation remains untouched during shadow period.

PHASE 3 · WEEKS 5-6

Progressive cutover

Traffic ramps from 10 percent to 50 percent to 90 percent to 100 percent over 14 days. Rollback capability at each step preserved. Cutover decision points have explicit go/no-go criteria measured against shadow phase parity baselines.

PHASE 4 · WEEK 7

PowerMTA decommission

Bird license cancellation at next renewal cycle. PowerMTA infrastructure retained in cold standby for 30 days as insurance. Final post-migration audit confirms KumoMTA stable operation. Runbook handover to client team if managed contract not extended.

When the reverse migration happens: 3 of our migrations went from KumoMTA back to PowerMTA between 2024 and 2026. The reasons in each case: Lua scripting complexity exceeded the in-house team's comfort threshold, KumoMTA edge cases in production hit the team faster than expected, or the institutional knowledge depth on PowerMTA was deeper than the savings justified rewriting. We are open about these cases because the migration decision is bidirectional. License cost is the dominant variable in 2026 economics, but operational risk tolerance and team comfort with Lua are non-trivial second variables. The discovery call covers these explicitly before any contract conversation.
Honest comparison · KumoMTA vs PowerMTA vs Halon vs MailerQ · 2026 reality

Four MTAs, four different fits. No single right answer.

Each MTA fits a specific situation. The comparison below uses the dimensions that matter most for the engineering decision: license model, configuration philosophy, multi-tenancy primitive, observability defaults, talent pool depth in 2026, and total cost at 5M monthly messages running 6 nodes. The numbers reflect 2026 reality, not aspirational marketing.

Dimension KumoMTA PowerMTA (Bird) Halon MailerQ
License model Apache 2 · free Commercial · quote-based Commercial Commercial · €25K/yr unlimited
Configuration philosophy Lua policy as code Directive-based config files HSL scripting XML + JSON + AMQP queues
Hot-reload behavior 300s native Restart required for most changes Selective hot-reload Selective hot-reload
Multi-tenancy primitive Per-tenant queue native virtual-mta (manual coord) Multi-tenant via HSL Queue-driven external
OS support Linux only Linux + Windows Linux only Linux only
Observability defaults Prometheus + JSON logs Custom accounting logs Built-in analytics External via queues
Talent pool depth (2026) growing rapidly 20+ years deep Niche but stable Smallest of four
Total cost · 6 nodes 5M msgs $0 license + ops $36K-$64K/yr license + ops ~€42K/yr license + ops €25K/yr license + ops
Maturity in production 28 months 25+ years 15+ years 10+ years
Honest reading of the four: if license cost dominates the budget conversation and your team is comfortable with Lua, KumoMTA is the clear answer at zero license cost. If your team has 20+ years of PowerMTA institutional knowledge, the operational risk of migration may exceed license savings, in which case PowerMTA stays the right answer at $36K-$64K annual license. If your business specifically needs HSL scripting for highly programmable mail flows beyond what Lua supports cleanly, Halon is the right answer at premium European pricing. If your architecture already runs on AMQP queues and external message routing, MailerQ's queue-driven model fits naturally at €25K annual unlimited. Where KumoMTA loses today: 28 months of production maturity versus PowerMTA's 25 years means edge cases are still being discovered, and the talent pool of engineers with hands-on KumoMTA production exposure is thinner than PowerMTA's. Where KumoMTA wins: economics at scale, modern architecture aligned with cloud-native deployment patterns, native multi-tenancy primitive that PowerMTA bolted on later. The decision depends on what your engineering team values most.
Three managed tiers · monthly contracts · 90-day initial commitment · cancel anytime after

KumoMTA managed pricing matched to your infrastructure footprint.

Monthly contracts. 90-day initial commitment at contract start, then month-to-month. KumoMTA managed pricing runs structurally lower than PowerMTA managed because the engine carries no recurring license cost, so the price reflects pure operational labor without vendor relationship overhead with Bird. No hidden upcharges for KumoCorp paid support tier (which is independent and the client purchases separately if desired). Migration scope from PowerMTA quoted separately at $14K-$28K one-time depending on configuration depth.

Single-node managed

One KumoMTA node. Business-hours coverage.

$1,490 / month
  • One KumoMTA node managed
  • init.lua policy authoring + maintenance
  • Daily monitoring + weekly review
  • Monthly SLA report (6-page PDF)
  • Git-backed runbook + Lua policy repo
  • Pool rotation senior engineer
  • 4h response window business hours
  • Quarterly version upgrade evaluation
  • Hot-reload verification on every commit
Book Single-node

Enterprise managed

7-20 nodes. Multi-region. 1h response 24x7.

$7,890 / month
  • 7 to 20 KumoMTA nodes managed
  • Multi-region failover (up to 2 regions)
  • 1h response 24x7 + 15min ack
  • Dedicated account engineer
  • Biweekly stakeholder review
  • Quarterly disaster recovery drill
  • Monthly version upgrade review
  • Post-mortem within 2 business days
  • Lua policy code review on every commit
Book Enterprise
Above 20 nodes or above 2 regions: custom-quoted, typically lands between $10,000 and $18,000 monthly depending on node count, geographic distribution, and SLA requirements. Below the volume floor: we do not take new managed contracts under 500K monthly messages because the engagement economics do not work below that threshold and KumoMTA's complexity is not justified at that volume; for sub-500K deployments we recommend Postfix via Mailcow which handles 95 percent of low-volume use cases without the operational overhead of KumoMTA. Migration from PowerMTA quoted separately as one-time scope before the managed contract begins. The discovery call closes with explicit fit verdict: managed service fits about 65 percent of inbound KumoMTA inquiries, 20 percent get redirected to KumoCorp paid support or Postmastery for deliverability strategy, 15 percent decide PowerMTA stays the right answer for their operational risk tolerance.
Hard questions on the technical call

What CTOs and VP Engineering ask before signing the migration contract.

"KumoMTA only launched in 2023. How can it be production-ready already?"

Fair concern, asked on roughly 80 percent of discovery calls. The honest framing: KumoMTA is built by Wez Furlong who spent nearly a decade as Chief Architect at Message Systems where he designed the Momentum/Ecelerity MTA, one of PowerMTA's only real competitors with 20+ years of production history. The core architecture is not novice work, it is the mature application of two decades of MTA-building experience to a fresh codebase under modern architectural constraints. The Rust async runtime is conservative and well-understood. The Lua policy layer is conservative and well-understood. Where the maturity gap is real: 28 months of production exposure versus PowerMTA's 25 years means edge cases are still being discovered, particularly around obscure ISP throttle policies and exotic bounce code patterns that PowerMTA has documented for two decades. How we mitigate the maturity gap: we run shadow deployments before any cutover, we maintain rollback to PowerMTA for at least 30 days post-migration, and we participate in the upstream KumoMTA community to surface edge cases as soon as we encounter them. Three migrations we completed went to KumoMTA and stayed; three reversed back to PowerMTA when the team determined Lua complexity exceeded license savings. The reverse capability is real and we discuss it openly.

"Why would I pay you to manage open-source software I could run myself?"

Same reason organizations pay AWS to run open-source databases or pay HashiCorp to manage open-source tooling: operational expertise compounds value beyond the software itself. KumoMTA managed value lives in three places: the Lua policy authoring (writing init.lua that handles your specific multi-tenant architecture, ISP throttle policies, retry ladder logic, bounce categorization rules takes 60 to 120 hours of senior engineering time per deployment), the operational discipline (alert rule calibration against your specific traffic shape, hot-reload verification on every commit, version upgrade evaluation against KumoCorp release notes, sysctl tuning for your specific kernel), and the talent pool risk amortization (replacing a senior KumoMTA engineer in 2026 takes 4 to 9 months of search). If your team has 60-120 hours of slack engineering capacity to invest in init.lua authoring, the operational maturity to run alert rules without false-positive fatigue, and tolerance for the talent pool risk, in-house operation is genuinely the right answer. Managed service fits when those conditions do not hold. About 25 percent of inbound KumoMTA inquiries decide in-house operation makes more sense after the discovery call, and we say so honestly.

"How is this different from KumoCorp's own paid support tier?"

KumoCorp ships paid support tiers from KumoMTA's own authors, which is genuinely different from operational managed service. What KumoCorp paid support does best: direct authorship of upstream patches when bugs surface in production, deep architectural consulting on novel use cases, official escalation path into the engineering team that wrote the engine, formal SLA on bug-fix turnaround. What managed service from EMP does best: 24x7 operational coverage with on-call response windows, alert rule calibration to your specific traffic shape, daily/weekly/monthly cadence of operational reviews, Git-backed runbook documenting every operational decision, hands-on infrastructure work that KumoCorp's product engineering team does not typically do at the operational layer. The two are complementary, not competitive. About 18 percent of our active KumoMTA managed contracts also hold KumoCorp paid support tier on top, and the combination works well: KumoCorp handles upstream code questions and architectural consulting, EMP handles continuous operational coverage. We coordinate transparently with KumoCorp's team when client issues benefit from upstream attention, with no revenue capture pressure on either side.

"What's the realistic talent risk if I commit to KumoMTA in production?"

Honest assessment of the 2026 talent landscape. The KumoMTA engineer pool is structurally thin because the engine launched at end of 2023, so the maximum hands-on production exposure any candidate can claim is approximately 28 months. The talent pool is growing rapidly: the open-source community is active, KumoCorp is hiring, Postmastery runs KumoMTA professional services, multiple ESPs have publicly announced KumoMTA migrations which trains additional engineers in production. Compared to PowerMTA's talent pool (which has 25 years of production engineers across the industry), KumoMTA's pool today is roughly 1/30th the size. Practical implications for your hiring strategy: a senior KumoMTA hire today commands a salary premium of 8 to 15 percent over equivalent PowerMTA seniority because of scarcity, the talent search runs 30 to 60 days longer than for PowerMTA equivalents, and onboarding is structurally easier because KumoMTA's documentation is excellent and the codebase is open source. The talent risk is real but bounded: we do not recommend KumoMTA migration for organizations where single-engineer continuity risk dominates, and we recommend PowerMTA stays the right answer in those cases.

"Can you help if my migration goes wrong mid-cutover?"

Yes, and this is engineered into the migration playbook by design. Three rollback layers preserved through all four phases: Layer 1 is shadow deployment, where KumoMTA only handles 5-10 percent of canary traffic during weeks 3-4 and main domain reputation stays untouched. If shadow phase metrics fail parity against PowerMTA baselines, we abort the migration before cutover begins, you keep PowerMTA fully operational, and the migration scope completes as a feasibility audit rather than a successful migration. Layer 2 is progressive cutover, where traffic ramps 10/50/90/100 percent over 14 days with explicit go/no-go criteria at each step, and rollback to the previous traffic split is a DNS or load balancer change taking under 5 minutes. Layer 3 is post-cutover insurance, where PowerMTA infrastructure stays in cold standby for 30 days after Phase 4 completes. If a regression surfaces during the 30-day window, we revert to PowerMTA hot in under 30 minutes via DNS cutover. What we cannot guarantee: that every migration succeeds. 3 of 9 attempted migrations during 2024-Q1 2026 reversed back to PowerMTA mid-cutover or during the 30-day insurance window. The reverse capability is structural to the playbook, not a fallback we improvise. Migration scope billing is structured around milestones, so if migration aborts during Phase 2, only Phase 1-2 fees apply.

"Why should I trust an operator from Panama on cloud-native KumoMTA?"

Geography is irrelevant to MTA expertise; production exposure is what matters, and EMP brings 16 years of commercial MTA operation since 2010. The commercial MTA experience translates directly to KumoMTA managed work because the operational disciplines (alert rule calibration, sysctl tuning, IP pool design, retry ladder logic, bounce categorization) are engine-agnostic. KumoMTA-specific exposure at EMP: 6 PowerMTA-to-KumoMTA migrations completed since 2024, plus 4 greenfield KumoMTA deployments, plus active participation in the upstream community. Latency from Panama for managed-service operational tasks is irrelevant: configuration changes, log analysis, incident response are all asynchronous activities where geography does not affect operational quality. Production traffic flows through the client's chosen region, not Panama. Where Panama jurisdiction matters: our infrastructure is operated under Ley 81 which sits outside the US CLOUD Act, which is a feature for clients who specifically prefer that posture for their operational vendor. Communication: all senior engineers operate fluent English at technical depth, written communication and runbooks delivered in English by default. About 22 percent of active KumoMTA managed contracts are with US-based clients, 28 percent EU/UK, the rest Latin America and Canada.

FAQ · technical questions covered on every discovery call

What the discovery call covers.

Why migrate from PowerMTA to KumoMTA in 2026?
  • Economics at scale: ESP with 10 PowerMTA nodes pays $60K-$105K/year in Bird license fees including dev/staging/DR surcharges, KumoMTA Apache 2 eliminates that recurring cost completely
  • Cloud-native fit: Linux-only, Kubernetes-native, Prometheus default, structured JSON logs
  • Hot-reload: Lua policies refresh every 300 seconds without operational restart
  • Native multi-tenancy: per-tenant queue isolation as first-class primitive

Tradeoffs: Lua learning curve steeper than directive config, 28 months production maturity vs PowerMTA's 25 years, talent pool smaller (growing rapidly).

What does day-to-day managed operation actually look like?
  • Daily alerts: queue depth per tenant, deferral spikes per ISP, hot-reload verification, accounting log integrity, IP reputation drift
  • Weekly review: traffic shaping calibration, tenant throttle review, IP rotation balance, Lua policy code review on commits
  • Monthly: KumoMTA version upgrade evaluation against KumoCorp release notes, capacity planning, alert recalibration
  • Every action logged to Git-backed runbook + Lua policy repo, client read access from day one
  • Client retains root SSH at all times, not exclusively vendor-portal operation
How is this different from hiring a KumoMTA engineer in-house?
  • Senior KumoMTA engineer: $200K-$280K loaded US/CA, $130K-$190K EU
  • Talent pool max 28 months production exposure (engine launched late 2023)
  • Search runs 30-60 days longer than equivalent PowerMTA hire
  • Single-engineer continuity risk for niche skill
  • EMP pool: primary + secondary + tertiary coverage on every account
  • Runbook + Lua policy repo portable to client team if contract ends
What versions of KumoMTA do you support?
  • KumoMTA 2024.x: initial production-ready releases, long-tail clients
  • KumoMTA 2025.x: mainstream production, most current deployments
  • KumoMTA 2026.x: current release line, recommended for new deployments
  • Pre-release alpha/beta: not supported, compliance risk
  • Linux-only: RHEL 9 / Rocky 9 / AlmaLinux 9 / Ubuntu 22/24 LTS / Debian 12
  • No Windows Server support upstream, no Linux compat shims contrived
How do you handle a PowerMTA-to-KumoMTA migration?

Migration scope $14K-$28K one-time, 4 phases over 7 weeks:

  • Phase 1 weeks 1-2: configuration translation (virtual-mta → egress_pool, bounce_pattern → bounce_classifier, retry-interval → traffic shaping)
  • Phase 2 weeks 3-4: shadow deployment 5-10% canary traffic
  • Phase 3 weeks 5-6: progressive cutover 10/50/90/100% over 14 days
  • Phase 4 week 7: PowerMTA decommission + 30-day cold standby insurance
  • 6 migrations completed 2024-Q1 2026, plus 3 reversed back to PowerMTA
What about Lua policy debugging and observability?
  • Layer 1 logs: kumo.log() calls within policy hooks, shipped to Loki with parsing rules
  • Layer 2 metrics: Prometheus /metrics endpoint, scraped every 15s, custom tenant metrics
  • Layer 3 CI: validate-shaping binary runs on every Lua commit before deployment
  • Full policy script version-controlled in Git from day one
  • Code review on every commit (client team or EMP depending on contract)
  • Hot-reload window measured to verify 300s propagation
  • Rollback: git revert + 300s wait, deterministic
How does pricing compare to PowerMTA managed and other options?
  • EMP KumoMTA Single-node: $1,490/mo vs PowerMTA $1,890/mo
  • EMP KumoMTA Cluster: $3,990/mo vs PowerMTA $4,890/mo
  • EMP KumoMTA Enterprise: $7,890/mo vs PowerMTA $9,890/mo
  • KumoCorp paid support: independent, complementary not competitive
  • Postmastery KumoMTA: deeper deliverability strategy, EU pricing
  • ~$400-$2K/mo delta reflects Bird vendor relationship overhead removed
What if I want to start with KumoMTA but later add PowerMTA for a specific use case?

Hybrid stacks are real and increasingly common in 2026:

  • KumoMTA primary + PowerMTA secondary for Windows Server use cases
  • PowerMTA primary migrating to KumoMTA + PowerMTA secondary legacy
  • About 12% of active managed contracts are hybrid PMTA + Kumo
  • Same managed fee covers both engines, proportional to node count not engine count
  • Operational discipline transfers across both engines
  • Runbook captures decisions per engine without conflating

Discovery call: 45 minutes. Migration feasibility, license savings, fit verdict.

Discovery format: 45-minute video call covering your current MTA stack (PowerMTA version + node count + monthly volume + Bird annual license cost), in-house engineering capability with Lua, multi-tenancy requirements, cloud-native posture, observability stack already in use. Output: explicit fit verdict (KumoMTA migration fits your situation, KumoMTA stays the wrong answer for you, OR you should evaluate KumoCorp paid support before committing to managed service), license savings calculation against your specific Bird quote, proposed migration timeline if fit confirmed, draft Statement of Work delivered within 48 hours. We sign mutual NDA before any technical detail is exchanged. About 65 percent of discovery calls convert to engagement, 20 percent get redirected to alternatives, 15 percent decide PowerMTA stays the right answer for their risk tolerance. The discovery call is genuinely diagnostic, not a sales pitch in disguise.

45-min discovery · Mutual NDA · Migration feasibility · Draft SoW within 48h · 90-day initial commitment then month-to-month