# Beton — Full Site Bundle > Concatenated Markdown for every page on www.getbeton.ai. Each page is also available individually by appending `.md` to its URL. Generated: 2026-05-09T13:05:56.194Z --- # Beton - Revenue Intelligence on Your Own Data > Beton's agent finds buying signals in your data warehouse, backtests them, and routes the revenue-driving ones to your CRM. Open source under AGPLv3. *Source: [https://www.getbeton.ai/](https://www.getbeton.ai/)* ## Find the buying signals already in your data Beton's agent reads your data warehouse, finds patterns that predict revenue, and routes the revenue-driving ones to your CRM. Open source under AGPLv3 — self-host or Cloud. ## Integrations - **Postgres** (source) — Connect any Postgres warehouse as a behavioral data source. Replicas, Supabase, self-hosted — Beton reads schema and discovers signals directly. - **PostHog** (source) — Connect your PostHog instance as the primary data source for behavioral signal detection. Backtest hypotheses on your event history before any signal goes live. - **Stripe** (source) — Stripe billing events as a signal source. Trial-to-paid conversions, plan upgrades, payment failures, churn — joined with product behavior for sharper signals. - **Firecrawl** (source) — Give Beton's agent business context by letting it crawl your own site (and soon your customers') — pricing, features, integrations, blog. Better context, sharper signals. - **Attio** (destination) — Route signals to Attio CRM. Automatically create and update records when buying signals are detected. Field-level mapping; never overwrites user-entered data. - **Apollo** (destination) — Enrich detected signals with Apollo contact and company data, then push the enriched record into your CRM or sequence. Fewer manual lookups; faster outbound. - **Webhooks** (destination) — Send signals to any tool via webhooks. HMAC-signed JSON payloads, retries with backoff, delivery logs. The escape hatch for everything Beton doesn't natively integrate with. --- # About Beton > Beton is open-source revenue intelligence that detects behavioral signals in product usage data and routes them to CRM and sales tools. *Source: [https://www.getbeton.ai/about/](https://www.getbeton.ai/about/)* ## Our Mission We believe that product usage data is the most honest signal of customer intent. Not form fills, not email opens — actual product behavior. Beton exists to make these signals actionable for revenue teams. ## The Problem We Solve Product-led growth companies generate massive amounts of product analytics data. But this data rarely reaches the people who need it most — sales teams, customer success managers, and revenue operations. The result is missed opportunities, reactive sales processes, and churn that could have been prevented. ## Our Approach Beton connects your product analytics (PostHog) to your revenue tools (CRMs, webhooks, automation platforms). We detect behavioral signals that indicate buying intent, expansion readiness, or churn risk, and route them to the right people at the right time. ### What Makes Beton Different - **Open source (GPL)**: Full transparency, full control. Self-host or use our cloud. - **No data hoarding**: Beton reads your events and routes signals. We don't store your product data. - **Behavioral signals, not lead scores**: Real product engagement patterns, not arbitrary point systems. - **Multi-destination routing**: One signal to many tools simultaneously. ## The Company Beton is built by a team of repeat founders and published ML researchers. We're a small, focused team building tools that bridge the gap between product analytics and revenue operations. ## Open Source Beton is licensed under AGPLv3. We believe open-source infrastructure for revenue intelligence makes the ecosystem stronger. You can view, modify, and self-host the entire codebase. See more info in our [Github repo](https://github.com/getbeton/inspector). --- # Pricing > Beton pricing: Self-hosted is free with your own LLM key. Cloud starts at $0.50 per tracked user per month. Enterprise add-ons available. *Source: [https://www.getbeton.ai/pricing/](https://www.getbeton.ai/pricing/)* --- # Privacy Policy > Privacy Policy for Beton revenue intelligence platform. Learn how we handle your data, cookies, and privacy rights. *Source: [https://www.getbeton.ai/privacy/](https://www.getbeton.ai/privacy/)* **Last updated: February 2026** ## 1. Introduction PGS-Sheben Inc. ("Beton," "we," "us," or "our") operates the Beton revenue intelligence platform at getbeton.ai. This Privacy Policy explains how we collect, use, and protect your information. ## 2. Information We Collect ### Account Information When you create a Beton Cloud account, we collect: - Name and email address - Organization name - Billing information (processed by our payment provider) ### Product Analytics Data Beton connects to your PostHog instance to read product analytics events. We do **not** store your product analytics data. We process events in real-time to detect behavioral signals and route them to your configured destinations. ### Signal Metadata We briefly retain signal metadata (signal type, timestamp, destination status) for routing and debugging purposes. This metadata does not contain your end-users' personal data. ### Website Usage On getbeton.ai, we collect standard web analytics via Google Tag Manager, including: - Page views and navigation patterns - Browser type and device information - Referral source - Approximate location (country/region level) ## 3. How We Use Your Information We use collected information to: - Provide and maintain the Beton service - Process signal routing between your data sources and destinations - Send account-related communications - Improve the Service based on aggregated usage patterns - Comply with legal obligations ## 4. Cookie Policy ### Cookies We Use **Necessary Cookies**: Required for the website and service to function. Cannot be disabled. - Session management - Cookie consent preferences **Analytics Cookies**: Help us understand how visitors use our website. Loaded via Google Tag Manager only with your consent. - PostHog analytics - Google Analytics **Marketing Cookies**: Used to measure the effectiveness of our marketing campaigns. Loaded via Google Tag Manager only with your consent. - Advertising pixels ### Managing Cookies You can manage your cookie preferences using the cookie consent banner on our website. You can also disable cookies in your browser settings, though this may affect functionality. ## 5. Data Sharing We do not sell your personal data. We may share information with: - **Service providers**: Payment processors, hosting providers (Vercel), and tools necessary to operate the Service - **Your configured destinations**: Signal data is routed to CRMs and tools you connect (Attio, HubSpot, Zoho, Pipedrive, webhooks) - **Legal requirements**: When required by law, regulation, or legal process ## 6. Data Security We implement appropriate technical and organizational measures to protect your information, including encryption in transit and at rest, access controls, and regular security reviews. ## 7. Data Retention - **Account data**: Retained while your account is active and for a reasonable period after deletion - **Signal metadata**: Retained for up to 30 days for debugging purposes - **Product analytics data**: Not retained — processed in real-time and not stored ## 8. Your Rights (GDPR) If you are in the European Economic Area, you have the right to: - **Access** your personal data - **Rectify** inaccurate personal data - **Erase** your personal data ("right to be forgotten") - **Restrict** processing of your personal data - **Port** your data to another service - **Object** to processing of your personal data - **Withdraw consent** for cookie-based tracking To exercise these rights, contact us at [privacy@getbeton.ai](mailto:privacy@getbeton.ai). ## 9. International Transfers Your information may be transferred to and processed in countries other than your own. We ensure appropriate safeguards are in place for international data transfers. ## 10. Children's Privacy Beton is not directed at children under 16. We do not knowingly collect personal data from children. ## 11. Changes to This Policy We may update this Privacy Policy from time to time. We will notify you of material changes by posting the updated policy with a new "Last updated" date. ## 12. Contact For privacy-related inquiries, contact us at [privacy@getbeton.ai](mailto:privacy@getbeton.ai). PGS-Sheben Inc. --- # Terms and Conditions > Read the Terms and Conditions for Beton, the open-source revenue intelligence platform. Covers self-hosted, cloud, and enterprise service usage policies. *Source: [https://www.getbeton.ai/terms/](https://www.getbeton.ai/terms/)* **Last updated: February 2026** ## 1. Agreement to Terms By accessing or using Beton ("the Service"), operated by PGS-Sheben Inc. ("we," "us," or "our"), you agree to be bound by these Terms and Conditions. If you do not agree, do not use the Service. ## 2. Description of Service Beton is an open-source revenue intelligence platform that detects behavioral signals in product usage data and routes them to CRM and sales tools. The Service is available as: - **Self-Hosted**: Free to deploy on your own infrastructure under GPL license - **Cloud**: Managed hosting at per-user pricing - **Enterprise**: Custom deployment with additional features and support ## 3. Account Registration To use Beton Cloud, you must create an account and provide accurate, complete information. You are responsible for maintaining the confidentiality of your account credentials and for all activities under your account. ## 4. Acceptable Use You agree not to: - Use the Service for any unlawful purpose - Attempt to gain unauthorized access to the Service or its systems - Interfere with or disrupt the Service or servers - Reverse engineer the Service (except as permitted by GPL license for self-hosted) - Use the Service to process data in violation of applicable privacy laws ## 5. Data Processing Beton reads product analytics events from your connected data sources (e.g., PostHog) and routes signals to your configured destinations (e.g., CRM systems). We do not store your product analytics data beyond what is necessary for signal routing. See our Privacy Policy for details. ## 6. Open Source License The self-hosted version of Beton is licensed under the GNU General Public License (GPL). Your use of the self-hosted version is governed by the GPL in addition to these Terms. ## 7. Cloud Service Terms For Beton Cloud: - Billing is based on tracked users per month - We provide a 99.9% uptime SLA for paid plans - You may cancel at any time; cancellation takes effect at the end of the billing period - Refunds are not provided for partial billing periods ## 8. Intellectual Property Beton, the Beton logo, and getbeton.ai are trademarks of PGS-Sheben Inc. The open-source codebase is available under GPL. All other content on this website is owned by PGS-Sheben Inc. ## 9. Limitation of Liability To the maximum extent permitted by law, PGS-Sheben Inc. shall not be liable for any indirect, incidental, special, consequential, or punitive damages arising from your use of the Service. ## 10. Disclaimer of Warranties The Service is provided "as is" and "as available" without warranties of any kind, either express or implied, including but not limited to implied warranties of merchantability and fitness for a particular purpose. ## 11. Indemnification You agree to indemnify and hold harmless PGS-Sheben Inc. from any claims, damages, or expenses arising from your use of the Service or violation of these Terms. ## 12. Changes to Terms We may update these Terms from time to time. We will notify users of material changes by posting the updated Terms on this page with a new "Last updated" date. ## 13. Governing Law These Terms are governed by and construed in accordance with applicable laws. Any disputes shall be resolved in the appropriate jurisdiction. ## 14. Contact For questions about these Terms, contact us at [legal@getbeton.ai](mailto:legal@getbeton.ai). --- # Pricing details *Source: [https://www.getbeton.ai/pricing/](https://www.getbeton.ai/pricing/)* ## Self-Hosted — Free Full control. Deploy on your own infrastructure with GPL license. - Unlimited users - All signal detection features - All CRM integrations - Sync data – weekly - Signal detection – weekly - Webhook & n8n support - Bring your own LLM key - Community support - GPL licensed ## Cloud — $0.50 Managed hosting. No data storage on our side, instant setup. - Everything in Self-Hosted - Sync data – daily - Signal detection – daily - Managed infrastructure - No data storage on Beton side - Instant setup — connect PostHog in minutes - Automatic updates - Priority support - 99.9% uptime SLA ## Enterprise — Custom For organizations with advanced security, compliance, and deployment needs. - Everything in Cloud - Sync data – every 4 hours - Signal detection – every 4 hours - Air-gapped deployment - Role-based access controls - White-glove onboarding - Custom integrations - Dedicated support - SLA guarantees ## FAQ ### What counts as a tracked user? A tracked user is any unique email in your PostHog instance that Beton monitors for behavioral signals. ### Does Beton store my product data? No. Beton reads events from your PostHog instance and routes signals to your CRM. We don't store your granular product analytics data (e.g. particular events or groups of events) but we store results of aggregated analytics. Self-hosting is always available and free with your own LLM keys. If you want we can do an airgapped deployment – it comes with a silver hat. ### What LLM key do I need for self-hosted? The self-hosted version requires an API key from a supported LLM provider (OpenAI, Anthropic, Gemini, Openrouter or compatible). This is used for signal detection heuristics. You control the model and costs. ### Which CRMs are supported? Attio is the natively supported destination today. HubSpot is on the immediate roadmap. For everything else (Pipedrive, Zoho, Salesforce, Close, custom CRMs), the Webhooks integration routes any signal to any HTTPS endpoint — and because Beton is open source, you can drop in a destination adapter yourself. ### Do I need PostHog to use Beton? PostHog is the primary product-analytics source, but you can also connect a Postgres warehouse (RDS, Cloud SQL, Supabase, self-hosted) or Stripe directly — Beton reads schema and runs signal discovery against any of them. Vertica and Trino are on the roadmap. ### Is Beton really open-source? Yes. Beton is licensed under GPL. You can view, modify, and self-host the entire codebase. The cloud version provides managed hosting on the same open-source code. ### Is there a free trial for Cloud? Yes. You can start a free trial of Beton Cloud with no credit card required. Connect your PostHog instance and see signals within minutes. --- # Team > The people building Beton *Source: [https://www.getbeton.ai/team/](https://www.getbeton.ai/team/)* ## Vlad Nadymov — Founder & CEO Co-founded Beton after watching every PLG team rebuild the same hypothesis-and-backtest flow from scratch. Previously: data and product roles at Handl.ai (YC), inDrive, Borzo Delivery, and Rainbow AI. ## Aleks Markelov — Co-Founder & CTO Deep learning researcher turned engineering leader. Previously built AI-powered document processing at Handl.ai (YC) and developer tools at Manuscript. Studied at MIPT (Moscow Institute of Physics and Technology). --- # Postgres Integration > Connect any Postgres warehouse as a behavioral data source. Replicas, Supabase, self-hosted — Beton reads schema and discovers signals directly. *Source: [https://www.getbeton.ai/integrations/postgres/](https://www.getbeton.ai/integrations/postgres/)* **Category:** source **Vendor URL:** https://www.postgresql.org/ ## How it works 1. **Connect a read-only role** — Provide a connection string. Beton uses a single read-only role and never writes back. Your Postgres takes no extra load — Beton schedules its own scans on a quiet replica or off-peak window. 2. **Beton proposes hypotheses** — The agent reads schema (tables, columns, foreign keys) and proposes testable behavioral hypotheses tailored to YOUR table layout — no generic templates. 3. **Backtest before promotion** — Each hypothesis is validated against historical rows: precision, recall, lift over baseline. Promote only the ones that beat your bar. ## Features - Read-only connection — zero impact on production - Works with managed Postgres (RDS, Cloud SQL), Supabase, and self-hosted - Automatic schema introspection — no manual table mapping - Compatible with warehouse loaders like Fivetran, Segment, RudderStack - Same hypothesis-and-backtest flow as PostHog - No data export or migration required ## Use cases - Run signal discovery on a production replica - Use Beton on warehouse data piped from Segment / Fivetran / RudderStack - Cross-reference event data with internal product tables (subscriptions, deals, support tickets) - Run signal hunts on Supabase-backed apps ## Setup snippet *Provision a read-only role for Beton (run in psql)* ```bash CREATE ROLE beton_readonly LOGIN PASSWORD ''; GRANT CONNECT ON DATABASE your_db TO beton_readonly; GRANT USAGE ON SCHEMA public TO beton_readonly; GRANT SELECT ON ALL TABLES IN SCHEMA public TO beton_readonly; ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO beton_readonly; ``` --- # PostHog Integration > Connect your PostHog instance as the primary data source for behavioral signal detection. Backtest hypotheses on your event history before any signal goes live. *Source: [https://www.getbeton.ai/integrations/posthog/](https://www.getbeton.ai/integrations/posthog/)* **Category:** source **Vendor URL:** https://posthog.com ## How it works 1. **Connect your PostHog instance** — Provide your PostHog project API key. Beton connects directly to your instance — Cloud or self-hosted. No data export, no migration. 2. **Agent proposes signal hypotheses** — The agent reads your event taxonomy and person/group properties, then proposes hypotheses (e.g. "users who hit 5+ workspace events in their first session convert at 4× baseline"). 3. **Backtest before promotion** — Each hypothesis is scored on your last 90 days of events: precision, recall, lift. Approve a hypothesis once it clears your bar — only then does it route signals. ## Features - Direct API connection — no data export needed - Real-time event processing on a sync schedule (every few minutes) - Supports all PostHog event types and properties - Historical backtesting on the last 90 days of events - Zero impact on your PostHog performance — read-only, batched, rate-limit-aware - Works with PostHog Cloud and self-hosted ## Use cases - Detect when free users exhibit buying behavior in your product - Identify power users ready for expansion conversations - Spot churn signals before users downgrade or leave - Route product-qualified leads to your sales team automatically ## Sample payload ```json { "hypothesis_id": "hyp_8g2k", "hypothesis": "Users who invite a teammate within 7 days of signup", "backtest": { "window_days": 90, "precision": 0.71, "recall": 0.42, "lift_vs_baseline": 4.3, "sample_size": 1284 }, "status": "approved" } ``` ## FAQ ### Do I need to export my PostHog data to use Beton? No. Beton reads events directly from your PostHog instance via the API — PostHog Cloud or self-hosted both work. Nothing is copied or migrated. You provide connection credentials and can revoke access at any time. ### Does Beton slow down my PostHog instance? No. Beton queries event batches on a schedule (typically every few minutes) rather than streaming every event, and respects PostHog's rate limits. In practice the read load is a few queries per sync interval. ### Which PostHog event types does Beton analyze? Beton reads standard event types (pageviews, custom events, group events, identify calls) plus person and group properties. The agent proposes hypotheses automatically — you don't need to pre-define which events matter. ### Does Beton store the raw PostHog events? No. Beton reads events, computes signals, and stores only the signal output (type, confidence, events referenced). Granular product analytics data stays in PostHog. --- # Stripe Integration > Stripe billing events as a signal source. Trial-to-paid conversions, plan upgrades, payment failures, churn — joined with product behavior for sharper signals. *Source: [https://www.getbeton.ai/integrations/stripe/](https://www.getbeton.ai/integrations/stripe/)* **Category:** source **Vendor URL:** https://stripe.com ## How it works 1. **Add a Stripe restricted key** — Generate a restricted API key (read-only on customers, subscriptions, invoices, charges, events). Paste it into Beton — no webhook setup required. 2. **Beton joins billing with product behavior** — Subscription state changes, plan switches, failed charges, and trial conversions are joined with PostHog/Postgres events on email or domain. Signals carry both contexts. 3. **Backtest revenue-grade hypotheses** — Hypotheses like "trialists who hit feature X within 3 days convert at Y%" are validated against actual paid conversions in your Stripe history. ## Features - Restricted-key OAuth — read-only, scoped, revocable - Subscription, invoice, charge, and customer events ingested - Auto-joined with product analytics on email and domain - Trial-conversion and expansion hypotheses validated on real revenue outcomes - Failed-payment and downgrade signals route to CRM as churn-risk - Works with Stripe test mode for staging environments ## Use cases - Detect trial users likely to convert before the trial ends - Spot accounts about to upgrade based on usage + billing trajectory - Catch payment-failure churn signals and route to CS - Validate "feature X drives expansion" claims against actual MRR data ## Sample payload ```json { "signal_type": "trial_about_to_convert", "confidence": 0.88, "sources": ["stripe", "posthog"], "account": { "email": "jane@acme.com", "domain": "acme.com" }, "stripe": { "subscription_status": "trialing", "trial_end": "2026-05-04", "plan_amount": 4900 }, "product_events": ["workspace_invited_teammate", "api_key_created", "workflow_published"] } ``` --- # Firecrawl Integration > Give Beton's agent business context by letting it crawl your own site (and soon your customers') — pricing, features, integrations, blog. Better context, sharper signals. *Source: [https://www.getbeton.ai/integrations/firecrawl/](https://www.getbeton.ai/integrations/firecrawl/)* **Category:** source **Vendor URL:** https://www.firecrawl.dev/ ## How it works 1. **Add your Firecrawl API key** — Drop your Firecrawl key into Beton settings. Beton uses it to crawl your own site. 2. **Agent reads context** — The agent ingests pricing pages, feature docs, blog posts, integration directories — building a working model of what your product does and how it monetizes. 3. **Sharper hypotheses** — When the agent looks at warehouse events, it interprets them in the context of your actual product, not in isolation. ## Features - Bring your own Firecrawl API key (Cloud or self-hosted) - Crawl pricing, features, blog, integrations, and other public pages - Context fed directly into hypothesis generation - Coming soon: per-customer crawl during analysis (B2B context awareness) ## Use cases - Help the agent understand what your product does without you writing a brief - Disambiguate event names by reading what the corresponding feature actually is - Coming soon: contextualize a customer's industry or stack during analysis --- # Attio Integration > Route signals to Attio CRM. Automatically create and update records when buying signals are detected. Field-level mapping; never overwrites user-entered data. *Source: [https://www.getbeton.ai/integrations/attio/](https://www.getbeton.ai/integrations/attio/)* **Category:** destination **Vendor URL:** https://attio.com ## How it works 1. **Connect your Attio workspace** — Authenticate with an Attio API key. Beton auto-discovers your objects, lists, and custom attributes — no manual schema setup. 2. **Configure signal-to-attribute mapping** — Map each signal type to specific Attio attributes (signal_type, confidence, events, detected_at). Optionally append entries to a list per signal. 3. **Signals flow to Attio in real-time** — When Beton detects a revenue signal, it upserts the matching Company/Person record by domain or email, appending signal context without touching fields you set manually. ## Features - Automatic Company and Person upsert by domain/email - Custom attribute mapping for signal context - Optional list-entry creation per signal type - Bi-directional ID linking — find the matching record in Attio from Beton - Configurable routing rules per signal type - Never overwrites user-entered data — append-only on existing fields ## Use cases - Auto-create deals when buying signals are detected - Enrich contact records with product usage context - Update deal stages based on behavioral signals - Alert sales reps in Attio when accounts show expansion intent ## FAQ ### What does Beton create in Attio? Beton upserts Companies and People, writes custom attributes for signals (type, confidence, event list, detected timestamp), and can add entries to a list of your choice. You configure which list and which attributes in Attio's workspace settings. ### Can I map Beton signals to Attio deals or tasks? Yes. Beton supports creating tasks, updating deal-stage attributes, and posting to Attio Activities via Attio's native objects. Configuration lives in each signal's destination settings. ### Does Beton overwrite existing Attio records? Beton never overwrites user-entered data. It uses Attio's upsert APIs with domain or email as the matching key, appending new signal attributes without touching fields you've set manually. ### Do I need an Attio paid plan? Any Attio plan that exposes the API works, including the Free plan for light usage. Heavier signal volumes may require Plus or Pro due to Attio's API call limits. --- # Apollo Integration > Enrich detected signals with Apollo contact and company data, then push the enriched record into your CRM or sequence. Fewer manual lookups; faster outbound. *Source: [https://www.getbeton.ai/integrations/apollo/](https://www.getbeton.ai/integrations/apollo/)* **Category:** destination **Vendor URL:** https://www.apollo.io ## How it works 1. **Add your Apollo API key** — Drop in your Apollo key. Beton uses it for organization-enrich, people-search, and people-match. 2. **Auto-enrich detected signals** — When a signal fires for an account, Beton hits Apollo's organization-enrich and finds the matching ICP contacts (title filters, location filters, seniority). Reveal optional. 3. **Route enriched records onward** — Push the signal + enriched contact into your CRM (Attio), kick off an Apollo sequence, or webhook the full payload anywhere. ## Features - Organization enrichment by domain — firmographic context per signal - People search with ICP filters (title, seniority, location) - People match (reveal) — full contact data, 1 credit per reveal - Apollo-side sequence enrollment (paused or live) - Cost-aware: respects your Apollo credit balance, with per-signal caps - Works with both Apollo workspaces and Apollo individual plans ## Use cases - Auto-find the buyer when a PQL signal fires (no rep research) - Enrich churn-risk signals with the relevant exec contact for retention - Trigger an Apollo sequence the moment a buying signal lands - Feed enriched signals into outbound systems beyond Apollo ## Sample payload ```json { "signal_type": "product_qualified_lead", "account": { "domain": "acme.com", "name": "Acme Corp" }, "apollo_enrichment": { "industry": "SaaS", "employee_count": 142, "funding_stage": "Series B", "primary_contact": { "name": "Jane Doe", "title": "VP of Revenue Ops", "email": "jane@acme.com", "linkedin": "https://linkedin.com/in/janedoe" } }, "sequence_enrolled": "plg-pql-q2" } ``` --- # Webhooks Integration > Send signals to any tool via webhooks. HMAC-signed JSON payloads, retries with backoff, delivery logs. The escape hatch for everything Beton doesn't natively integrate with. *Source: [https://www.getbeton.ai/integrations/webhook/](https://www.getbeton.ai/integrations/webhook/)* **Category:** destination **Vendor URL:** # ## How it works 1. **Configure your webhook endpoint** — Provide an HTTPS URL plus an HMAC shared secret. Add custom headers for auth, tagging, or routing on your end. 2. **Filter and shape the payload** — Choose which signal types to forward and (optionally) transform the payload to match your system's expected shape. 3. **Receive signals in real-time** — Your endpoint receives a POST with full signal context every time a matching signal is detected. Failed deliveries retry with exponential backoff (10× / 24h). ## Features - Standard HTTP POST with JSON payloads - HMAC-SHA256 signed (X-Beton-Signature header) - Configurable custom headers and basic auth - Signal type filtering - Payload transformation and field mapping - Retry logic — exponential backoff, 10 attempts over 24 hours - Delivery logs visible in the Signals dashboard ## Use cases - Send signals to Slack channels for team visibility - Trigger custom scripts, n8n workflows, or serverless functions - Feed signals into data warehouses or analytics tools - Build custom integrations with internal tools or homegrown CRMs ## Sample payload ```json { "signal_type": "product_qualified_lead", "confidence": 0.92, "source": "posthog", "hypothesis_id": "hyp_8g2k", "account": { "name": "Acme Corp", "domain": "acme.com" }, "events": ["visited_pricing_page", "invited_team_member", "api_key_created"], "enrichment": { "company_size": "50-200", "industry": "SaaS" }, "detected_at": "2026-04-29T14:31:08Z" } ``` ## FAQ ### How are webhook payloads authenticated? Beton signs every request with HMAC-SHA256 using a shared secret you configure. The signature is in the X-Beton-Signature header. Basic auth and custom headers are also supported for legacy systems. ### Can I retry failed webhook deliveries? Yes. Beton retries failed deliveries with exponential backoff up to 10 attempts over 24 hours. Delivery logs are visible in the Signals dashboard so you can debug endpoint issues. ### Can I use webhooks to talk to n8n, Zapier, or Make? Yes — point the webhook URL at any of those services' webhook trigger endpoints. The standard JSON shape works out of the box for n8n trigger nodes, Zapier catch hooks, and Make scenarios. ### What does the webhook payload contain? A JSON object with signal_type, confidence, source, hypothesis_id, account (name, domain), events, enrichment, and detected_at. A sample payload is shown on this page. --- # Dryfit Scenario: Combined coverage (all models) > A single dataset exercising the union of all supported event names across every business-model variant. Use this when you want one dataset that covers every signal type for Grafana-wide inspection or multi-agent testing. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-combined-coverage/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-combined-coverage/)* **Scenario kind:** posthog_business_models_combined **Use-case kind:** combined **Value metric:** Union of event types across all business models **Config file:** `configs/posthog_business_models_combined_mvp.yaml` **Dataset id:** `posthog_business_models_combined_mvp_v1` ## Scale - Accounts: 360 - Users per account (mean): 5 - Sessions per user (mean): 10 - Duration: 30 days **Success event:** `upgrade_clicked` (account) ## Research metrics - Coverage across all business models ## Positive signals (ground truth) - **limit_modal_upgrade** (count 50): `limit_reached → upgrade_modal_shown → upgrade_clicked` - **gate_usage_upgrade** (count 30): `feature_gate_shown → api_request → compute_hours_used → upgrade_clicked` ## Negative signals (ground truth) - **instrumentation_without_upgrade** (count 35): `source_connected → $pageview → custom_event_tracked` - **credit_warning_without_upgrade** (count 30): `credits_used → low_balance_warning` --- # Dryfit Scenario: Contact / record-based SaaS > CRM- or marketing-style SaaS priced by record count. Imports and enrichment drive positive signals; segmentation without growth is a negative pattern. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-contact-record/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-contact-record/)* **Scenario kind:** posthog_contact_record **Use-case kind:** record-count **Value metric:** Contacts, leads, subscribers, accounts managed **Config file:** `configs/posthog_contact_record_mvp.yaml` **Dataset id:** `posthog_contact_record_mvp_v1` ## Scale - Accounts: 300 - Users per account (mean): 4 - Sessions per user (mean): 7 - Duration: 30 days **Success event:** `contact_created` (account) ## Research metrics - Contact growth rate - % of contact limit used - Import frequency ## Positive signals (ground truth) - **import_to_contact_growth** (count 85): `list_imported → contact_created` - **enriched_contact_creation** (count 45): `contact_created → enrichment_completed → contact_created` ## Negative signals (ground truth) - **import_segment_stall** (count 60): `list_imported → segment_created` - **contact_segment_without_growth** (count 45): `contact_created → segment_created` --- # Dryfit Scenario: Credits / token-based > Prepaid credit or token systems where burn and top-up patterns matter more than traditional funnels. Low-balance warnings into purchases are the key positive signal. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-credits-token/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-credits-token/)* **Scenario kind:** posthog_credits_token **Use-case kind:** credit **Value metric:** Credits consumed, tokens used, compute units **Config file:** `configs/posthog_credits_token_mvp.yaml` **Dataset id:** `posthog_credits_token_mvp_v1` ## Scale - Accounts: 3000 - Users per account (mean): 8 - Sessions per user (mean): 16 - Duration: 300 days **Success event:** `credits_purchased` (account) ## Research metrics - Burn rate - Days-to-zero - Top-up frequency - Auto-refill adoption ## Positive signals (ground truth) - **warning_to_purchase** (count 850): `low_balance_warning → credits_purchased` - **auto_refill_conversion** (count 450): `low_balance_warning → auto_refill_triggered → credits_purchased` ## Negative signals (ground truth) - **burn_to_warning_only** (count 650): `credits_used → low_balance_warning` - **repeated_warning_decline** (count 350): `low_balance_warning → low_balance_warning` --- # Dryfit Scenario: Event-volume SaaS > Analytics or observability SaaS priced by ingested volume. Source connections and custom events drive positive signals; stale sources are negatives. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-event-volume/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-event-volume/)* **Scenario kind:** posthog_event_volume **Use-case kind:** ingest **Value metric:** Events tracked, data points ingested, log lines **Config file:** `configs/posthog_event_volume_mvp.yaml` **Dataset id:** `posthog_event_volume_mvp_v1` ## Scale - Accounts: 320 - Users per account (mean): 4 - Sessions per user (mean): 10 - Duration: 30 days **Success event:** `custom_event_tracked` (account) ## Research metrics - Ingestion volume trend - Event-type diversity - New-source activation rate ## Positive signals (ground truth) - **source_to_custom_event** (count 75): `source_connected → $pageview → custom_event_tracked` - **schema_then_custom_event** (count 40): `schema_changed → custom_event_tracked` ## Negative signals (ground truth) - **source_pageview_only** (count 65): `source_connected → $pageview` - **repeated_schema_changes** (count 30): `schema_changed → schema_changed` --- # Dryfit Scenario: Feature-gated (tiered) SaaS > Tiered SaaS where paywalls drive upgrades. Feature-gate hits followed by upgrade clicks are positive; downgrades and gate-only hits are negative. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-feature-gated/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-feature-gated/)* **Scenario kind:** posthog_feature_gated **Use-case kind:** tiered **Value metric:** Plan tier / feature access level **Config file:** `configs/posthog_feature_gated_mvp.yaml` **Dataset id:** `posthog_feature_gated_mvp_v1` ## Scale - Accounts: 260 - Users per account (mean): 4 - Sessions per user (mean): 8 - Duration: 30 days **Success event:** `upgrade_clicked` (account) ## Research metrics - Gate-hit frequency - Advanced-feature attempt rate - Time between gate hits ## Positive signals (ground truth) - **gate_to_upgrade** (count 75): `feature_gate_shown → upgrade_clicked` - **advanced_feature_gate_upgrade** (count 40): `advanced_feature_attempted → feature_gate_shown → upgrade_clicked` ## Negative signals (ground truth) - **advanced_feature_denied** (count 65): `advanced_feature_attempted → feature_gate_shown` - **upgrade_then_downgrade** (count 25): `upgrade_clicked → downgrade` --- # Dryfit Scenario: Freemium-to-paid > Freemium SaaS where the wedge into paid is running up against free-tier limits. Limit-reached events feeding modals and trial starts are the signal chain. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-freemium-to-paid/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-freemium-to-paid/)* **Scenario kind:** posthog_freemium_to_paid **Use-case kind:** freemium **Value metric:** Free-tier limit hits that drive paid conversion **Config file:** `configs/posthog_freemium_to_paid_mvp.yaml` **Dataset id:** `posthog_freemium_to_paid_mvp_v1` ## Scale - Accounts: 280 - Users per account (mean): 4 - Sessions per user (mean): 8 - Duration: 30 days **Success event:** `trial_started` (account) ## Research metrics - Time-to-limit - Limit-hit frequency - Conversion funnel drop-off ## Positive signals (ground truth) - **limit_modal_trial** (count 80): `limit_reached → upgrade_modal_shown → trial_started` - **blocked_feature_trial** (count 45): `feature_blocked → upgrade_modal_shown → trial_started` ## Negative signals (ground truth) - **limit_modal_dropoff** (count 60): `limit_reached → upgrade_modal_shown` - **repeated_feature_blocks** (count 40): `feature_blocked → feature_blocked` --- # Dryfit Scenario: Hybrid (seat + usage) > Hybrid pricing that combines per-seat licensing with metered overage. Positive signals chain through invite, signup, activation, and compute usage — exercising the longest legitimate path in any scenario. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-hybrid-seat-usage/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-hybrid-seat-usage/)* **Scenario kind:** posthog_hybrid_seat_usage **Use-case kind:** hybrid **Value metric:** Seats plus usage overage **Config file:** `configs/posthog_hybrid_seat_usage_mvp.yaml` **Dataset id:** `posthog_hybrid_seat_usage_mvp_v1` ## Scale - Accounts: 320 - Users per account (mean): 5 - Sessions per user (mean): 9 - Duration: 30 days **Success event:** `compute_hours_used` (account) ## Research metrics - Seat growth plus usage acceleration - Overage frequency ## Positive signals (ground truth) - **seat_growth_then_usage_growth** (count 70): `invite_sent → user_signed_up → seat_activated → api_request → compute_hours_used` - **activated_usage_completion** (count 45): `seat_activated → api_request → job_completed → compute_hours_used` ## Negative signals (ground truth) - **seats_without_usage** (count 60): `invite_sent → user_signed_up → seat_activated` - **request_job_no_overage** (count 55): `api_request → job_completed` --- # Dryfit Scenario: Platform / marketplace > Two-sided marketplace where active listings are the key metric. Positive signals chain from account connection through storefront activation to listing publication. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-marketplace/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-marketplace/)* **Scenario kind:** posthog_marketplace **Use-case kind:** marketplace **Value metric:** Listings, storefronts, connected accounts, integrations **Config file:** `configs/posthog_marketplace_mvp.yaml` **Dataset id:** `posthog_marketplace_mvp_v1` ## Scale - Accounts: 240 - Users per account (mean): 5 - Sessions per user (mean): 8 - Duration: 30 days **Success event:** `listing_published` (account) ## Research metrics - Active listing growth - Seller/buyer activation rate - Marketplace liquidity ratio ## Positive signals (ground truth) - **connected_storefront_listing** (count 70): `account_connected → storefront_activated → listing_published` - **integration_listing_publish** (count 45): `integration_enabled → listing_published` ## Negative signals (ground truth) - **connected_storefront_stall** (count 55): `account_connected → storefront_activated` - **integration_backtracking** (count 35): `integration_enabled → account_connected` --- # Dryfit Scenario: PostHog Web (baseline) > The minimum-viable PostHog scenario. A generic event stream with a two-step conversion funnel and corresponding negative path. Good starting point for signal-detection benchmarking before moving to business-model-specific variants. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-web/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-web/)* **Scenario kind:** posthog_web **Use-case kind:** baseline **Value metric:** Generic SaaS activation (baseline) **Config file:** `configs/posthog_mvp.yaml` **Dataset id:** `posthog_mvp_v1` ## Scale - Accounts: 500 - Users per account (mean): 4 - Sessions per user (mean): 10 - Duration: 30 days **Success event:** `purchase` (account) ## Research metrics - Baseline conversion rate - Funnel drop-off ## Positive signals (ground truth) - **billing_then_purchase** (count 80): `page_billing → purchase` - **invite_then_api_key_then_purchase** (count 35): `invite_teammate → api_key_created → purchase` ## Negative signals (ground truth) - **billing_dropout** (count 70): `page_billing → page_pricing` - **pricing_only_stall** (count 110): `page_pricing → page_pricing` --- # Dryfit Scenario: Revenue-share / take-rate > Take-rate platforms earning a cut of processed bookings. Commission calculation closes the positive funnel; uncalculated payouts are negatives. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-revenue-share/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-revenue-share/)* **Scenario kind:** posthog_revenue_share **Use-case kind:** take-rate **Value metric:** Revenue processed, bookings, GMV through platform **Config file:** `configs/posthog_revenue_share_mvp.yaml` **Dataset id:** `posthog_revenue_share_mvp_v1` ## Scale - Accounts: 240 - Users per account (mean): 4 - Sessions per user (mean): 7 - Duration: 30 days **Success event:** `commission_calculated` (account) ## Research metrics - GMV growth trend - Take-rate stability - Payout frequency ## Positive signals (ground truth) - **booking_to_commission** (count 75): `booking_completed → commission_calculated` - **booking_payout_commission** (count 40): `booking_completed → payout_processed → commission_calculated` ## Negative signals (ground truth) - **booking_payout_only** (count 45): `booking_completed → payout_processed` - **repeated_payout_without_commission** (count 20): `payout_processed → payout_processed` --- # Dryfit Scenario: Seat-based SaaS > Per-seat licensing SaaS where growth is measured in active seats. The funnel runs from invite to signup to seat activation, with deactivation as a churn signal. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-seat-based/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-seat-based/)* **Scenario kind:** posthog_seat_based **Use-case kind:** per-seat **Value metric:** Active seats / users **Config file:** `configs/posthog_seat_based_mvp.yaml` **Dataset id:** `posthog_seat_based_mvp_v1` ## Scale - Accounts: 3000 - Users per account (mean): 5 - Sessions per user (mean): 8 - Duration: 364 days **Success event:** `seat_activated` (account) ## Research metrics - Seat growth % - Active/total seat ratio - Invite-to-activation rate ## Positive signals (ground truth) - **invite_signup_activation** (count 80): `invite_sent → user_signed_up → seat_activated` - **role_assignment_activation** (count 55): `role_assigned → seat_activated` ## Negative signals (ground truth) - **invite_signup_stall** (count 60): `invite_sent → user_signed_up` - **activation_then_deactivation** (count 35): `seat_activated → seat_deactivated` --- # Dryfit Scenario: Storage-based SaaS > Storage-tier SaaS where the expansion signal is growth toward tier limits. Storage warnings serve as quota-risk signals. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-storage-based/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-storage-based/)* **Scenario kind:** posthog_storage_based **Use-case kind:** capacity **Value metric:** GB stored, records managed, files hosted **Config file:** `configs/posthog_storage_based_mvp.yaml` **Dataset id:** `posthog_storage_based_mvp_v1` ## Scale - Accounts: 260 - Users per account (mean): 4 - Sessions per user (mean): 7 - Duration: 30 days **Success event:** `file_uploaded` (account) ## Research metrics - Storage growth rate - Days-to-tier-limit - Upload frequency trend ## Positive signals (ground truth) - **record_then_upload** (count 80): `record_created → file_uploaded` - **repeated_upload_growth** (count 55): `file_uploaded → file_uploaded` ## Negative signals (ground truth) - **upload_hits_storage_warning** (count 45): `file_uploaded → storage_warning_shown` - **repeated_storage_warning** (count 25): `storage_warning_shown → storage_warning_shown` --- # Dryfit Scenario: Transaction / volume-based SaaS > Payment and transaction platforms where value tracks with successful throughput. Positive signals end in payment completion; negative signals include refunds and invoice stall. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-transaction-volume/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-transaction-volume/)* **Scenario kind:** posthog_transaction_volume **Use-case kind:** volume **Value metric:** Transactions processed, GMV, payments **Config file:** `configs/posthog_transaction_volume_mvp.yaml` **Dataset id:** `posthog_transaction_volume_mvp_v1` ## Scale - Accounts: 280 - Users per account (mean): 4 - Sessions per user (mean): 7 - Duration: 30 days **Success event:** `payment_completed` (account) ## Research metrics - Transaction volume trend - Avg transaction value growth - Transaction frequency per account ## Positive signals (ground truth) - **order_to_payment** (count 90): `order_created → payment_completed` - **invoice_to_payment** (count 50): `order_created → invoice_generated → payment_completed` ## Negative signals (ground truth) - **invoiced_not_paid** (count 55): `order_created → invoice_generated` - **refunded_volume** (count 30): `payment_completed → refund_issued` --- # Dryfit Scenario: Usage-based (metered) SaaS > Metered SaaS where revenue scales with consumption. Positive signals are completed jobs and compute cycles; negative signals are stalled usage. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-usage-based/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/posthog-usage-based/)* **Scenario kind:** posthog_usage_based **Use-case kind:** metered **Value metric:** API calls, compute hours, messages, requests **Config file:** `configs/posthog_usage_based_mvp.yaml` **Dataset id:** `posthog_usage_based_mvp_v1` ## Scale - Accounts: 320 - Users per account (mean): 4 - Sessions per user (mean): 9 - Duration: 30 days **Success event:** `job_completed` (account) ## Research metrics - Usage velocity - Quota consumption - Usage acceleration ## Positive signals (ground truth) - **request_to_job_completion** (count 95): `api_request → job_completed` - **message_compute_job** (count 45): `message_sent → compute_hours_used → job_completed` ## Negative signals (ground truth) - **request_compute_stall** (count 70): `api_request → compute_hours_used` - **message_only_repeat** (count 65): `message_sent → message_sent` --- # Dryfit Scenario: Telegram Chat > Simulates a Telegram-like chat environment with user interactions. Different event shape from the PostHog web scenarios — useful for testing agent portability across data sources. *Source: [https://www.getbeton.ai/oss-tools/dryfit/scenarios/telegram-chat/](https://www.getbeton.ai/oss-tools/dryfit/scenarios/telegram-chat/)* **Scenario kind:** telegram_chat **Use-case kind:** communication **Value metric:** Chat engagement / retention **Config file:** `configs/telegram_mvp.yaml` **Dataset id:** `telegram_mvp_v1` ## Scale - Accounts: 0 - Users per account (mean): 0 - Sessions per user (mean): 0 - Duration: 30 days **Success event:** `event_signup` (user) ## Research metrics - Active conversation rate - Response rate - Retention ## Positive signals (ground truth) - **message_reply_signup** (count 90): `message_sent → reply_received → event_signup` - **reaction_chain_signup** (count 40): `message_sent → reaction_received → event_signup` ## Negative signals (ground truth) - **message_then_silence** (count 80): `message_sent → reaction_received` - **leave_after_reply** (count 55): `message_sent → reply_sent → leave_group` --- # Documenso Pricing Teardown > Documenso has 12.7k GitHub stars, AGPL-3.0 licensing, and a $250/month Platform tier that quietly bets on DocuSign's per-envelope pricing being the competitor's biggest weakness. Here's how it actually works. *Source: [https://www.getbeton.ai/blog/documenso-pricing-teardown/](https://www.getbeton.ai/blog/documenso-pricing-teardown/)* **Published:** 2026-04-28 **Author:** Vlad Nadymov Hey, it's [Vlad](https://www.linkedin.com/in/vlad-nadymov/), founder of Beton. Documenso bills itself as "the open source DocuSign alternative." 12.7k stars on GitHub, AGPL-3.0 licensed, hosted product from $0 to $250/month across four tiers. The most interesting thing about it isn't the prices — it's what AGPL-3.0 does to the buying decision. *This post is a part of [series on commercial open source software pricing](https://learninglate.substack.com/p/pricing-the-commercial-open-source-software).* ## What is Documenso Open source e-signature. You upload a PDF, drag signature fields onto it, send it, recipients sign, you get a sealed PDF with an audit trail. Same loop as DocuSign, Dropbox Sign, Adobe Sign, PandaDoc — but the source is on GitHub. - Website: [documenso.com](https://documenso.com) - Pricing: [documenso.com/pricing](https://documenso.com/pricing) - GitHub: [github.com/documenso/documenso](https://github.com/documenso/documenso) — **12.7k stars** - License: AGPL-3.0 (this matters — see below) For context: DocuSign does ~$3B/year at a $15B+ market cap. Dropbox Sign and Adobe Sign carve up most of the rest. Documenso is the open source insurgent — not at scale yet, but the only credible "we run the source ourselves" option in the category. Even Google Docs has launched their own e-sign in a "make your complements free" defensive move. ## The AGPL-3.0 gate The license does most of the work the sales team would otherwise have to do. AGPL-3.0 is the most aggressive permissive-adjacent OSS license in widespread use. It's GPL with one extra clause: if you run AGPL software over a network and let users interact with it, you must release your modified source to those users. Fork Documenso, host it, let your customers sign through your product, and **you have to release whatever you built around it under AGPL too**. Self-hosting an internal company instance? Fine — your "users" are employees, and the source is already public. Embedding Documenso into a SaaS you sell to others? Not fine — your product becomes a "derivative work" the moment it links to Documenso's, and most commercial codebases cannot ship AGPL-derived code without becoming legally encumbered. This is why the **Platform plan exists at $250/month**. It's not a feature tier — it's the AGPL escape hatch. White-labeling, embedded signing, unlimited API are real features, but the actual thing you're paying $250/month for is permission. DocuSign and Dropbox Sign extract revenue through per-envelope pricing. Documenso extracts it through licensing. Same destination, different road. ## Pricing structure **Hosted plans:** - **Free — $0/month.** 5 documents/month, up to 10 recipients per doc, no credit card. Free forever, not a trial. - **Individual — $30/month** ($300/year, effectively $25/mo annual). Unlimited documents, API access for personal use, email support. - **Teams — $48/month** ($480/year, effectively $40/mo annual). 5 included users + $8/mo per additional user. Unlimited documents, embedded signing, API access for automation. - **Platform — $300/month** ($3,000/year, effectively $250/mo annual). Unlimited users, documents, API. Embedded signing with white-label, Slack support. **This is the AGPL commercial license tier.** - **Enterprise — talk to sales.** Cloud or self-hosted, advanced compliance, tailored support. **Self-hosted:** - **Community Edition (free, AGPL-3.0).** Unlimited signatures, no envelope cap, full feature parity for internal use. The catch is you take on AGPL's obligations. - **Enterprise (self-hosted).** Custom commercial license for orgs that want self-hosting *and* commercial-product embedding. ## The Free tier is unusually generous Most signing tools give you a "free trial" — 3 signs, then the wall. Documenso's Free is 5 documents per month, indefinitely, no credit card, no watermark, 10 recipients per doc. DocuSign's free is a 30-day trial. Dropbox Sign's free is 3 docs/month with watermarks. Adobe Sign has none. That's enough to handle a freelancer's contract flow or an indie founder's NDAs without ever paying. Hit the cap, and the upgrade to Individual at $25 is right there. Product-led growth with the brakes off. ## The pricing cliff Individual ($25) → Teams ($40) → Platform ($250). The first jump is fine. The second is dramatic: $210/month more for "unlimited everything." In practice, you don't pay Platform because you ran out of seats — Teams scales linearly at $8/extra user and most growing companies could ride it indefinitely. You pay $250 because you crossed a specific Rubicon: **you want to embed Documenso into a product you sell.** The marketing copy calls Platform "perfect for builders." That understates it. White-label and unlimited API are window dressing on a license sale. For internal-use companies — even very large ones — Teams is the right answer through hundreds of employees. ## Vs. DocuSign: the math depends on volume DocuSign API plans start around $20/month for 10 envelopes, then scale to $0.50–$2.00 per envelope at enterprise volume. Dropbox Sign runs similar: $99/month base for 200 requests + overage. Documenso Platform is $250/month flat, unlimited. - **500 signs/month** on DocuSign at ~$1/envelope = $500/mo. Documenso = $250/mo flat. - **5,000 signs/month** at $0.50/envelope = $2,500/mo. Documenso = $250/mo flat. - **50,000 signs/month** = $25k+/mo on DocuSign. Documenso = still $250. For any product team building signing into their own SaaS, the comparison isn't "Documenso vs. DocuSign as e-sig tools." It's "$250/month flat vs. a tax that scales with your customer adoption." The trade-off: DocuSign's brand, audit certifications stack, and integration surface (Salesforce, Workday, every legal tool ships a connector) are real assets — especially for a SaaS selling into Fortune 500 procurement. For technical buyers with high signature volume, Documenso Platform is the rational choice anyway. ## Self-hosting the AGPL way The repo ships Docker compose and a Helm chart. The stack is PostgreSQL, Redis, the server, and SMTP — smaller than most COSS deployments. Operationally you take on TLS, backups, SMTP, security review, and AGPL obligations if you ever expose it externally. For internal-use deployments at a single company, self-hosting is right once you're past Teams' break-even or have hard data-residency requirements. For embedding into a commercial product, self-hosting is *not* a way around Platform — AGPL still applies, and most proprietary codebases can't accept that. ## Worth paying for? **Free** is genuinely usable for low-volume individuals. 5 docs/month with no watermark is more than most people's actual contract flow. **Individual at $25/month** is a clean upgrade if you hit Free's cap and sign more than 5 things a month. **Teams at $40/month** is the SMB sweet spot. A 20-person company at $160/mo lands well under DocuSign's equivalent. **Platform at $250/month** is the right answer if and only if you're embedding Documenso into a product. The features are valuable; the AGPL escape hatch is the actual line item. If you're not embedding, you're overpaying. **Self-host** if you have ops capacity and you only need internal use. Don't self-host as a way to dodge Platform if you intend to embed — AGPL doesn't permit that. The honest take: Documenso's pricing is built around one strategic bet — that DocuSign's per-envelope billing is the category's biggest weakness for technical buyers, and that AGPL is a clean enough fence to monetize the people who want to escape it. For internal-use customers, Teams is the obvious win. For builders, Platform's $250/month against unlimited envelopes is one of the better deals in dev tools — as long as you understand the actual product you're buying is a license, not a feature set. --- *I build [Beton](https://getbeton.ai?utm_source=blog&utm_campaign=documenso_teardown&utm_medium=organic) — open source revenue intelligence for B2B SaaS.* --- # Beton late April 2026 update > Postgres support, multi-user workspaces, Firecrawl context, and a refreshed design just shipped. Editable field mapping, multi-action signal routing, and a multi-subagent rewrite of discovery are queued for this week. Plus pipeline color from a late-stage pilot. *Source: [https://www.getbeton.ai/blog/beton-late-april-2026-update/](https://www.getbeton.ai/blog/beton-late-april-2026-update/)* **Published:** 2026-04-27 **Author:** Vlad Nadymov hey, it's [Vlad](https://www.linkedin.com/in/vlad-nadymov/), founder of Beton. ten days since the last update. a big release went out to main, more is staged for later this week, and the GTM side has had a lot of motion — both with customers in the pipeline and on our own outbound learning. ## what just shipped ### Postgres as a data source Beton can now read directly from any Postgres warehouse, not just PostHog. same pattern as PostHog — schema analysis, behavioral hypothesis generation, statistical testing — but now against your raw warehouse. a Postgres replica from your production DB, a Supabase project, a self-hosted Postgres, or a separately maintained analytics warehouse all work. this is the use case we kept hearing: "PostHog is great, but our real behavioral data lives in Postgres." for teams that already use it as DWH — through Segment, Fivetran, RudderStack or custom ETL pipelines — Beton can now sit on top of the warehouse without forcing a migration to another product. we start by reading the schema, surfacing tables that look like behavioral fact tables (events, actions, transactions), and proposing hypotheses to test. the statistical validation layer is identical to the PostHog flow. connect it from the [Postgres integration page](/integrations/postgres). ### multi-user workspaces workspaces support multiple people now. invite teammates, assign roles (owner, admin, member), share signal pipelines without stepping on each other's field mappings. per-workspace integration credentials, per-workspace audit logs, and the foundation for proper team workflows. practically — when a signal fires, you can see who configured the pipeline that produced it, who's responsible for routing, and who's been alerted. that's table-stakes for any RevOps tool used by more than one person, and it's now in. ![Workspace settings — members, email/link invites, pending invites, domain claims](/images/blog/late-april-2026/workspace-settings.png) ### Firecrawl integration you can now add your Firecrawl API key in settings, and the agent will pick up context about your business directly from your own site. pricing pages, feature pages, blog posts, integration directories — anything we crawl gets ingested as context for hypothesis generation. this matters because most behavioral signals don't make sense in isolation. "user X clicked Y three times" is meaningless without knowing what Y is and what role it plays in your funnel. the agent reads your site, builds a working model of what the product does and how it monetizes, then uses that model to interpret the events it sees. next step: extending so the agent also scrapes context on your customers' companies during analysis. for B2B, the customer's industry and stack often change how a signal should be interpreted — a transaction-volume drop means something different at a fintech versus an e-commerce store, and the agent should adjust accordingly. set it up on the [Firecrawl integration page](/integrations/firecrawl). ### refreshed design + more agent memory the Inspector UI moved from near-total black-and-white to a refreshed design system with blue as an accent — still a color-blind safe palette, just less stark. cleaner navigation, sharper signal table, semantic badges for signal state. less visual noise. ![Signals page on the new design — semantic ACTIVE/DRAFT/CUSTOM badges, statcards with shadow borders, lift colors](/images/blog/late-april-2026/signals-list.png) the agent also remembers more between runs now — its query history, the hypotheses it tested last time, schema notes it built up — so the next session doesn't redo work the previous one already finished. consecutive runs converge on what matters faster. ## what's coming next week these are in final review now and shipping to main this week. ### field mapping the biggest UX shift in the queue. right now, mapping a signal output to an Attio CRM field is done only once during workspace setup. after next release you'll be able to change it on the fly. onboarding will guide you through field mapping in-line. integrations split cleanly into sources (where signals come from — PostHog, Postgres) and destinations (where they go — Attio, soon HubSpot). each destination has a visual mapper with three picker tabs: - **source** — pick a property directly off the signal payload - **property** — pick a static value or a workspace setting - **formula** — write a small expression with autocomplete (member email lookups, default fallbacks, conditionals) more than that, you'll be able to set up different behaviour for each signal. one signal can trigger multiple different actions in multiple destinations — so you can create a new CRM deal and send a Slack notif on one signal, while another updates the deal and adds the user to a PostHog cohort. ![Field mapping wizard — DEALS / PEOPLE / COMPANIES / WORKSPACES with per-row source pickers and inline test sends](/images/blog/late-april-2026/field-mapping.png) ### entity linking field mapping by itself just sets attribute values. entity linking is the harder part — when a signal fires, who is this about, and what records need to exist in the CRM for the action to land. the new release handles this without you writing any resolution code: - **people resolved by email.** when a signal carries a person's email, the system upserts an Attio person record by email — creating it if missing, updating it if found. - **companies resolved by domain.** same idea. the system asserts a company by domain. if a freshly-asserted person has no company link, it auto-links them to the matching company. - **account owner resolved by workspace member.** a `member(email)` formula in a mapping returns the matching Attio workspace member — so you can route deals to the AE who owns the account in one expression. - **specific records via search picker.** when you need to link to a particular record (a fixed campaign, a specific Slack channel as Attio object), the picker queries Attio's search endpoint live as you type. so a "high-intent visit on the pricing page" signal can simultaneously create a deal, attach the person who triggered it, attach their company by domain, and route the deal to the AE who owns that company — all from one signal definition, all from one UI, with the system doing the upsert plumbing. ### agent updates this release is mostly a wiring change, not a feature change. the discovery agent now runs as a sequence of four subagents instead of one monolithic prompt: 1. **site discovery + summary** — crawl the customer's site, extract product and positioning context, condense into a working brief that the rest of the pipeline reads 2. **DWH analysis** — connect to the warehouse, build a schema map, identify behavioral fact tables 3. **signal-hunting agent** — runs in a loop: generate a hypothesis, query the warehouse, evaluate, iterate. this is the only step that loops; the rest run once 4. **finalizer** — package the strongest hypotheses with their evidence into a structured handoff cleaner trace logs at every step, so you can inspect what each subagent did and why. we were running everything as one prompt before, which meant a failure anywhere blew up the whole run and made debugging painful. splitting it into named subagents makes failures localized and traces useful. the agent itself is open source. → inspector-ml-backend on GitHub after this release, we're wiring in our open-source statistical-methods toolkit as agent tools — Fisher exact, two-proportion z, Newcombe intervals, multiple-comparison correction. validation will run as a first-class step inside the loop instead of through a separate post-processing pass. that work is in flight; expect it in the next release. ### HubSpot integration every Beton user with HubSpot will be one OAuth click away from getting signal data right where their pipeline lives. ## GTM updates we're slowly progressing with early adopter pilots. ### a late-stage pilot with a marketplace platform our furthest-along pilot right now is with a marketplace serving SMB B2Bs — their sellers are small business operators who use the platform to run their core operations. the platform has thousands of these seller accounts. each one is small in revenue terms, but the long tail adds up to most of the company's volume. the problem they brought us: they have no behavioral way to know which sellers are slipping toward churn before renewal time. account managers can't watch thousands of accounts manually. renewal-time interventions are too late. we're running a backtested signal hunt on their warehouse — hypotheses like "when a seller goes A → B → C, does that predict churn over the next 30 days?" — discovered from historical event data and validated statistically across three layers: - **per-hypothesis stats** — Fisher exact, two-proportion z, Newcombe intervals - **holdout testing** — confirm the pattern holds on data the hypothesis wasn't generated from - **multiple-comparison correction** — so we don't fool ourselves with false positives at scale the signals that pass all three layers flow into their destination CRM with the relevant context attached. the CS team gets a prioritized worklist instead of spending time on customers not worth pursuing. ### pipeline is filling up three other live conversations, three different industries, similar problem shape: - **LTV defense for a delivery marketplace.** commodity-pricing competition is collapsing repeat-buy rates. they want cohorts whose repeat frequency is degrading inside the renewal window, before the customer tells them they're leaving. - **post-signup activation depth for a PLG marketing platform.** which first-week behaviors predict 14-day retention, which predict expansion, which predict no-show. signals routed to a tiered onboarding response. - **account stagnation detection for a security vendor.** big accounts that are technically still paying but have stopped using the product are leading indicators of non-renewal. find them earlier, intervene with product changes or success. different verticals, but the underlying ask is the same: a company has behavioral data in a warehouse, knows there's signal in there, doesn't have the team-time to hunt for it manually. Beton is the agent that does the hunting. you're an hour away from new retention drivers – just sign up, set up your account and wait for the agent to go through your data.
try Beton free →
## ask forward this to a CMO/Head of Sales friends of yours. happy to pay a finder's fee if we do a deal with them — [Vlad](https://www.linkedin.com/in/vlad-nadymov/) --- # Langfuse Pricing Teardown > Langfuse open sourced almost everything under MIT. The cloud pricing is usage-based with a $170 cliff between Core and Pro — here's what you're actually paying for. *Source: [https://www.getbeton.ai/blog/langfuse-pricing-teardown/](https://www.getbeton.ai/blog/langfuse-pricing-teardown/)* **Published:** 2026-04-20 **Author:** Vlad Nadymov Hey, it's Vlad, founder of Beton. Langfuse is one of those tools that every AI team ends up looking at eventually. You're shipping an LLM-powered feature, something goes wrong, and suddenly you realize you have zero visibility into what your model is actually doing. That's the gap Langfuse fills. What makes it interesting from a pricing standpoint is the licensing move they made in mid-2025 — they open sourced nearly everything under MIT. The commercial gating is now razor-thin. Let's break it down. *This post is a part of series on commercial open source software pricing.* ## What is Langfuse Langfuse is an open source LLM engineering platform. Tracing, prompt management, evaluations, datasets, playground — the full observability and iteration stack for AI applications. Think of it as Datadog for your LLM layer. You instrument your app with their SDK (Python, JS/TS, or OpenTelemetry), and Langfuse captures every trace — model calls, retrieval steps, agent actions, latency, tokens, cost. Then you use the dashboard to debug, evaluate, and improve. - 24,400+ GitHub stars - Y Combinator W23 - Built with TypeScript, backed by ClickHouse - 5.5M+ monthly SDK installs, 8,000+ self-hosted instances - Integrations with OpenAI, LangChain, LlamaIndex, LiteLLM, Vercel AI SDK, CrewAI, and dozens more The project has real momentum. It's become the default open source option in the LLM observability space, competing with Arize, Braintrust, and LangSmith. ## The licensing play This is where Langfuse stands out — and where the June 2025 announcement changed everything. **The core platform is MIT** Not AGPL. Not BSL. Not "sustainable use." MIT. The most permissive license there is. You can fork it, embed it, sell it, build a competing product on top of it. No strings. And it's not MIT for some stripped-down toy version. All the core product features — tracing, prompt management, LLM-as-a-judge evaluations, annotation queues, playground, prompt experiments, datasets — are MIT. Before June 2025, features like LLM-as-a-judge, the playground, and annotation queues were commercially licensed. They moved all of it to MIT. Their own blog post says it clearly: "we are open sourcing all remaining Product Features in Langfuse." **The enterprise edition is a thin shell** What's left in the commercial `ee/` directory? License checks and enterprise security features: - SCIM API for automated user provisioning - Audit logs - Data retention policies - Project-level RBAC (org-level RBAC is already MIT) - UI customization for self-hosted deployments That's it. The EE license requires a commercial agreement with Langfuse GmbH. You can read and modify the code for dev/testing, but you can't run it in production without paying. The split is clean: product features are free, platform team / compliance features are paid. SSO (including Okta and AzureAD) is MIT and available in the open source version. That's notably generous — most COSS companies gate SSO behind enterprise pricing. **What this means in practice** For a team that just needs LLM observability and evals: self-host the MIT version and you're done. Unlimited users, unlimited traces, unlimited retention, full feature set. No license gotchas. For a 500-person company that needs SCIM, audit logs, and data retention policies: you're buying the enterprise license. Fair enough. The bet Langfuse is making is that cloud convenience and enterprise compliance features are enough to build a business on, even when the core product is completely free. Given 8,000+ self-hosted instances, the top-of-funnel seems to be working. ## Pricing structure Langfuse Cloud uses usage-based pricing on top of flat monthly tiers. The billable unit is anything you send to their tracing API — traces, observations (spans, events, generations), and scores. One LLM call might generate multiple units depending on your instrumentation depth. **Cloud plans:** - **Hobby (free)** — 50k units/month, 30-day data access, 2 users. No credit card required. Enough to evaluate the product on a side project. - **Core — $29/month** — 100k units included, unlimited users, 90-day data access. Overage at $8/100k units (graduated — drops to $7 at 1M, $6.50 at 10M, $6 at 50M+). In-app support with 48h response SLO. - **Pro — $199/month** — 100k units included (same as Core), unlimited users, 3-year data access, data retention management, unlimited annotation queues, high rate limits (20k ingestion req/min vs 4k on Core), SOC2 & ISO27001 reports, BAA available for HIPAA. - **Pro + Teams add-on — $499/month** — Everything in Pro plus enterprise SSO (Okta), SSO enforcement, fine-grained RBAC, dedicated Slack/MS Teams support channel with 24h response SLO. - **Enterprise — $2,499/month** — Everything in Pro + Teams plus audit logs, SCIM API, custom rate limits, uptime SLA, support SLA, dedicated support engineer. Yearly commitment available with custom volume pricing and AWS Marketplace billing. **Self-hosted plans:** - **Open Source (free)** — MIT license. All core platform features. Unlimited everything. You manage your own ClickHouse instance. - **Enterprise (self-hosted)** — Custom pricing. Bundled with ClickHouse Cloud/BYOC/Private. Adds project-level RBAC, audit logs, data retention, SCIM, server-side data masking, UI customization, dedicated support engineer, solutions architect support. **The graduated usage pricing:** | Volume tier | Rate per 100k units | |---|---| | 0 - 100k | Included in plan | | 100k - 1M | $8 | | 1M - 10M | $7 | | 10M - 50M | $6.50 | | 50M+ | $6 | So a team generating 5M units/month on Core pays: $29 base + $0 (first 100k) + $72 (next 900k at $8) + $280 (next 4M at $7) = $381/month. Not cheap, but predictable. ## The pricing cliff The Core-to-Pro jump is the elephant in the room. $29 to $199 — a $170/month increase — for the exact same included usage (100k units). What do you actually get for that $170? 1. **3 years data access vs 90 days.** This is the big one. If you're building LLM features in a B2B product and need to look at historical traces for debugging or compliance, 90 days is genuinely limiting. Three years is essentially "forever" for most teams. 2. **Data retention management.** The ability to set TTLs and auto-delete data. Required for GDPR-conscious teams. 3. **Unlimited annotation queues** (vs 3 on Core). If you're doing systematic human evals, this matters. 4. **SOC2 & ISO27001 reports.** The compliance checkbox. If your customers are asking for these, you need Pro. 5. **Higher rate limits.** Ingestion jumps from 4k to 20k requests/minute. API from 100 to 1,000 requests/minute. For a solo developer or small startup without compliance requirements, Core is fine. For any B2B team whose customers will send a security questionnaire, Pro is effectively mandatory. That's intentional pricing design — compliance as the upgrade trigger. Then there's the Teams add-on at $300/month on top of Pro. Enterprise SSO and RBAC. If your company's IT policy mandates Okta login for all tools, you're at $499/month before any usage charges. That's the real "enterprise tax." And from $499 to Enterprise at $2,499 — a 5x jump — you're buying audit logs, SCIM provisioning, SLAs, and a dedicated human. This is pure enterprise sales territory. The product doesn't change much; the support and compliance wrapper does. ## Does it make sense to pay? **Self-hosting is genuinely viable.** Unlike Firecrawl where the value is managed infrastructure (proxies, browser pools), Langfuse's value as a self-hosted tool is the product itself. Docker compose gets you running in minutes. Helm chart for production Kubernetes. Terraform templates for AWS, Azure, GCP. The MIT license means no restrictions whatsoever. The catch is ClickHouse. Langfuse uses ClickHouse as its analytics database, and operating ClickHouse at scale is non-trivial. For a small team doing a few million traces/month, a single ClickHouse instance is fine. For high-volume production use, you need to think about replication, backups, and schema migrations. That's real ops work. **Cloud Core at $29/month is an easy yes** the moment you have a production LLM feature. The alternative — tailing logs, grepping for model outputs, manually checking responses — is absurd once you've seen proper tracing. $29/month is below the "think about it" threshold for any team with revenue. **Pro at $199/month is the compliance trigger.** You'll know when you need it because a customer or your security team will tell you. Until then, Core is enough. **Teams add-on ($300/month) is SSO tax.** Skip it unless your IT department forces the issue. **Self-host if you can.** The MIT license is clean, the product is complete, and you dodge the unit-based billing entirely. If you're already running ClickHouse or comfortable adding it to your stack, self-hosting is the highest-value option. No usage limits, no retention limits, no seat caps. You trade monthly fees for infra management. The honest take: Langfuse's pricing is reasonable for what it is, but the real story is the licensing. An MIT-licensed platform this feature-complete, with this much community adoption, makes self-hosting an unusually strong play. The cloud pricing exists for teams who value convenience over ops overhead — and there's nothing wrong with that. --- *I build [Beton](https://getbeton.ai) — open source revenue intelligence for B2B SaaS.* --- # We Open-Sourced Our Agent Testing Tool > Dryfit generates synthetic analytics databases with hidden ground truth so you can benchmark AI agents on product-signal discovery. MIT licensed. *Source: [https://www.getbeton.ai/blog/we-open-sourced-our-agent-testing-tool/](https://www.getbeton.ai/blog/we-open-sourced-our-agent-testing-tool/)* **Published:** 2026-04-16 **Author:** Vlad Nadymov At Beton, we build AI that detects revenue signals -- expansion readiness, churn risk, upsell timing — inside product analytics data. We needed a way to know whether they actually work. We had no customers -- so no data at hand. Our CTO had experience with generating different kinds of synthetic data before. So we built Dryfit. It helps us build signal validation tools for our ADK-based agentic system. ## What it does Dryfit generates a PostgreSQL events table that looks like real product telemetry — pageviews, feature usage, API calls, billing events — with synthetic but realistic patterns. Hidden inside the data are planted signals: behavioral sequences that indicate expansion, churn, or other outcomes. Alongside the database, Dryfit outputs a ground truth manifest that maps every planted signal to specific event IDs. Your agent runs against the database. You compare its findings to ground truth. You get a precise score. Think of it as unit tests for signal discovery. ## Who this is for If you're building any of the following, Dryfit solves the "what do I test against" problem: - **RevOps / PLG tools** that detect expansion or churn signals in product usage data. You need to know your agent catches the right accounts — not just the obvious ones. - **Customer health scoring systems** where you're assigning risk or readiness scores based on behavioral patterns. Without ground truth, you're guessing whether your scores are meaningful. - **AI agents that analyze product analytics** — the new wave of tools that connect to PostHog, Amplitude, or a data warehouse and surface insights. Your demo works, but does it work on messy, realistic data at scale? - **Data teams evaluating vendor claims.** If someone tells you their AI "finds signals in your data," hand them a Dryfit database and ask for their precision and recall. - **SQL practice on product data.** If you want to practice writing analytical queries against realistic product databases — or run a Kaggle-style signal discovery competition within your team — Dryfit gives you a ready-made dataset with verifiable ground truth. The common thread: you need a realistic dataset where you know the right answers ahead of time. ## Business model coverage Different SaaS business models produce different signal patterns. A seat-based product expands through invite, signup, activation sequences. A usage-based product shows acceleration in API calls or compute hours. A freemium product hits tier limits before converting. Dryfit ships 12 scenario configs covering the most common models: seat-based, usage-based, transaction volume, storage, contact/record-based, feature-gated, marketplace, revenue-share, credits/tokens, hybrid, freemium-to-paid, and event-volume. Each config defines the event vocabulary, positive signal paths (leading to the success event), negative signal paths (similar but not converting), and noise parameters. You can use them as-is or author your own. ## How to use it ```bash uv sync uv run dryfit -c configs/posthog_seat_based_mvp.yaml --print-summary ``` For visual inspection, spin up the Docker Compose stack with Grafana: ```bash docker compose up -d ``` ## Why open source We think the agentic AI space has a benchmarking gap. Everyone is building agents that "analyze data" or "find insights," but there's no standardized way to measure whether they actually find anything real. Dryfit is our contribution to closing that gap. MIT licensed. Use it, fork it, extend it. Built by [Aleksandr Markelov](https://github.com/Sashmark97). **GitHub:** [github.com/getbeton/dryfit](https://github.com/getbeton/dryfit) --- # Beton April 2026 Update > Slack integration, MCP server with OAuth, security audit, blog migration, and open-sourcing the agent. *Source: [https://www.getbeton.ai/blog/beton-april-2026-update/](https://www.getbeton.ai/blog/beton-april-2026-update/)* **Published:** 2026-04-14 **Author:** Vlad Nadymov Two months since the last update. Here's what shipped and what's coming. ## Slack Integration When a signal fires, Beton now pushes Block Kit-formatted notifications to your Slack channel with the context reps need to act — account name, signal type, confidence score, and a direct link back to Inspector. Full OAuth V2 flow, channel picker in settings, one-click setup. ## MCP Server: Now with OAuth We upgraded the embedded MCP server from API key auth to interactive OAuth login following RFC 9728. Streamable HTTP transport, dual-auth support, and a settings page with four tabs — setup instructions, method reference, connected sessions, and request logs. If you're wiring AI agents into your RevOps stack, this is the cleanest integration point we offer. ## Security Audit We ran a penetration test and remediated 32 vulnerabilities across multiple review rounds — cross-tenant data leaks, XSS vectors, error message sanitization, SSRF surface area. The boring kind of work that matters most. ## Blog Moved to Our Own Platform We migrated the blog from Substack to getbeton.ai. Every post now lives on our domain, which means the SEO value of our content actually compounds for us instead of for Substack. Same content, better distribution mechanics. ## Marketing Site Updates Added real company logos from signups as social proof. Fixed a pile of Google Search Console 404s — trailing slash redirects, catch-all rules that were blocking live pages, blog.getbeton.ai now redirects properly. Added an open source tools section and structured data improvements. On the SEO side, we launched a separate website to A/B test our approach — it pulls 1,500 views per day using the same playbook. The Beton site doesn't see that kind of traffic yet, which tells us the problem is with our site specifically, not the strategy. We're digging into what's different and fixing it. ## Coming Up **Postgres as a data source** is shipping this week. Same pattern as PostHog — schema analysis, hypothesis generation, statistical testing — but against raw Postgres databases. This opens Beton to teams that warehouse data outside PostHog or want to cross-reference multiple sources. We're also actively building **HubSpot integration** — full bidirectional sync with OAuth auth, a polling engine, MCP tools, and native signal detectors. And **multi-user workspaces** with invitations and role-based access are in progress, so your team can share one signal pipeline without stepping on each other's field mappings. But the big one: **we're open-sourcing the Beton agent this week.** Alongside it, we're launching statistical validation methods — a proper library of them. More on that very soon. --- # Twenty CRM Pricing Teardown > Twenty CRM at $9/user/month exposes how much of Salesforce and HubSpot pricing is brand tax. *Source: [https://www.getbeton.ai/blog/twenty-crm-pricing-teardown/](https://www.getbeton.ai/blog/twenty-crm-pricing-teardown/)* **Published:** 2026-04-06 **Author:** Vlad Nadymov This post is a part of series on commercial open source software pricing. See full list of articles [here](/blog/). Twenty is an open-source CRM gunning directly at Salesforce and HubSpot — full contact management, custom objects, API access, email integration. It's hit ~30k GitHub stars, which for a CRM (a category dominated by entrenched incumbents) is impressive. The pitch is: same functionality, fraction of the price, you own the data. - Website: [twenty.com](https://twenty.com) - Pricing: [twenty.com/pricing](https://twenty.com/pricing) - GitHub: [github.com/twentyhq/twenty](https://github.com/twentyhq/twenty) **Plans** - **Self-hosted (free):** Full AGPL license. Run it yourself, no limits. - **Pro — $9/user/month:** Unlimited records, custom objects, full API access, email integration, standard support. - **Organization — $19/user/month:** Everything in Pro + SAML/OIDC SSO, priority support. **The contrast with Salesforce is almost comical** Salesforce Starter is $25/user/month and doesn't include half of what Twenty's $9 plan covers. Salesforce Enterprise is $165/user/month. HubSpot Sales Hub Professional runs $90/user/month. Twenty at $9 is not just cheaper — it's in a different pricing universe. For a 10-person sales team, the delta between HubSpot Pro and Twenty Pro is $810/month. That's close to $10k/year for essentially the same features. The interesting question isn't why Twenty is cheaper. It's why incumbents charge so much for a CRM, a product category that's been solved for 20 years. Twenty's pricing exposes how much of Salesforce/HubSpot's cost is brand tax, ecosystem lock-in, and support overhead — not actual software value. **AGPL: the double-edged sword** Self-hosting is free — but AGPL comes with strings. If you modify Twenty and offer it as a service to others, you must open-source your modifications. For most companies using it internally, this doesn't matter at all. But if you're building a product on top of Twenty (say, an industry-specific CRM), you either have to open-source your product or pay for a commercial license. AGPL is intentional. It's the standard play for commercial open source: free for self-use, but building on top requires a conversation (and probably a contract). **The ops burden question** The Pro cloud tier is $9/user/month. The self-hosted tier is free. For a 10-person team, that's $90/month you're paying to not deal with database maintenance, upgrades, backups, and uptime. Whether $90/month is worth avoiding that ops burden depends entirely on your team. A startup with a DevOps engineer: probably self-host. A sales-led team with no infra experience: the $90/month is a bargain. The pricing works because the self-hosted option is genuinely competitive — it's not crippled. Twenty is betting on most teams being bad at ops, which is statistically correct. **License** AGPL v3. Completely free to self-host and use internally. If you're distributing or running a service built on Twenty, you need to open-source your code or negotiate a commercial license with the team. **Worth paying for?** At $9/user/month, this is one of the better deals in B2B software. If your team is already using Salesforce or HubSpot and the only reason you haven't switched is inertia, Twenty is worth a serious look. The self-hosted option is free and full-featured — pay only when you want someone else to run it. --- This post is a part of series on commercial open source software pricing. See full list of articles [here](/blog/). *I build [Beton](https://getbeton.ai?utm_source=learninglate&utm_campaign=twenty-crm_teardown&utm_medium=substack) — open source revenue intelligence for B2B SaaS.* --- # n8n Pricing Teardown > n8n charges per workflow execution, not per step. Here's why that matters for complex automations with AI chains and conditional branching. *Source: [https://www.getbeton.ai/blog/n8n-pricing-teardown/](https://www.getbeton.ai/blog/n8n-pricing-teardown/)* **Published:** 2026-03-25 **Author:** Vlad Nadymov n8n is a workflow automation tool designed for technical teams. It occupies a middle ground between Zapier (which is user-friendly but expensive) and building everything from scratch (free but time-consuming). The platform enables users to connect apps, databases, APIs, and AI models into automations called workflows. With over 180,000 GitHub stars, it represents the most-starred workflow automation project globally and has accelerated growth as development teams recognize their need to productionize AI agents. *Disclosure: Beton uses n8n for core GTM automation.* ## The Distinctive Feature: Execution-Based Pricing Unlike most automation tools that charge per step (Zapier calls these "tasks"), n8n employs execution-based pricing. One complete workflow run — from trigger to finish — costs the same regardless of how many steps it contains. For straightforward automations this distinction matters little. However, for complex workflows involving AI chains, multi-API enrichment pipelines, and conditional branching, this represents a substantial structural advantage. A 40-step workflow costs identically to a 2-step one. ## Pricing Plans **Starter — EUR 20/month (annual)** - 2,500 executions monthly - 5 concurrent executions - 1 shared project, 50 AI Workflow Builder credits - Cloud-hosted **Pro — EUR 50/month (annual)** - Custom execution quota (user-configured) - 20 concurrent executions - 3 shared projects, 150 AI credits - Workflow history, global variables, admin roles, execution search - Cloud-hosted **Business — EUR 667/month (annual)** - 40,000 executions monthly - 6 shared projects - SSO, SAML, LDAP, Git version control, multiple environments - Self-hosted only **Enterprise — Contact sales** - 200+ concurrent executions, unlimited projects - Log streaming, external secret store, 365-day execution logs - Cloud or self-hosted options Annual billing provides 17% savings. Startups with under 20 employees receive 50% off Business tier pricing. ## The Pricing Cliff A substantial jump exists between Pro (EUR 50/month) and Business (EUR 667/month) — a 13-fold increase. The Business tier requires self-hosting while adding essential enterprise features like SSO, multi-environment setup, and Git-based version control. This pricing structure intentionally targets organizations possessing existing DevOps capacity seeking simply a license. ## Licensing Considerations The Community Edition operates under n8n's Sustainable Use License — neither MIT, Apache, nor OSI-approved. Key restriction: users may self-host for their own team but cannot create competing products or operate it as a managed service for customers. License selection directly influences monetization strategy. Apache 2.0 or MIT would permit anyone to fork and commercialize n8n-as-a-service. The Sustainable Use License prevents this, protecting n8n's cloud business while permitting community use. AGPLv3 takes a different approach: requiring modified version distributions to be open-sourced while preventing AGPL code embedding in commercial customer products without licensing. For typical n8n users automating their own infrastructure, the license remains irrelevant. For anyone considering building atop n8n, it presents a deal-breaker. ## Value Assessment Self-hosting users needing SSO or multiple environments should almost always pay for Business tier — these represent substantive features rather than luxuries. Individual contributors and small teams should begin with Community Edition self-hosted, which provides genuine completeness with all integrations, unlimited workflows, and unlimited users. Migration to cloud Pro (EUR 50/month) makes sense upon requiring parallel executions or workflow history. One consideration: AI Workflow Builder credits function as a second metering mechanism layered atop executions. Currently limits remain generous enough to avoid impact, yet as agentic workflows dominate usage patterns, this represents the transparent next monetization lever. --- # Plane Pricing Teardown > Plane is an open-source Jira/Linear alternative you can self-host. Integrations are positioned as a deliberate growth lever — here's how the pricing works. *Source: [https://www.getbeton.ai/blog/plane-pricing-teardown/](https://www.getbeton.ai/blog/plane-pricing-teardown/)* **Published:** 2026-02-28 **Author:** Vlad Nadymov ## What is Plane Open-source project management software serving as a Jira/Linear/Monday alternative you can self-host. The platform features issues, sprints (called "cycles"), modules, pages, and multiple view options (kanban/gantt/calendar). Built with React + TypeScript frontend and Django + Python backend. - 46,100+ GitHub stars - AGPL-3.0 license - Raised $4M from OSS Capital and Sherpalo Ventures - Achieved #1 ranking in GitHub's project management category within one year ## The Licensing Approach The Community Edition uses AGPL-3.0 licensing — fully open with no hidden code or dependency on commercial versions. Two separate codebases ensure continuity if the company disappears. **Feature gating strategy**: Community Edition matches the cloud Free tier, providing projects, work items, cycles, modules, views, pages, estimates, and intake functionality. The Free tier is limited to 12 users. Integrations and marketplace access require Pro subscription ($6/seat). Additional paid features include: - Custom fields (Work Item Types and Properties) - Workspace Wiki - Time Tracking - Dashboards - Epics and Initiatives - Teamspaces Business plan ($13/seat) adds project templates, recurring work items, workflows/approvals, customers, advanced dashboards, and RBAC. ## Pricing Structure Per-seat pricing with included AI credits: - **Free**: $0, core PM, 12 user max, 500 AI credits/seat - **Pro**: $6/seat/month, custom fields, time tracking, dashboards, integrations, 1000 AI credits/seat - **Business**: $13/seat/month, RBAC, templates, workflows, 2000 AI credits/seat - **Enterprise Grid**: Custom quote with airgapped deployment, LDAP, audit logs Self-hosted editions mirror cloud tiers. ## Value Assessment A 10-person Pro team costs $720 annually versus $1,200 on Linear — 40% savings. The free tier genuinely serves small teams without project limitations or crippled features. The upgrade trigger occurs when integration needs emerge, custom fields become necessary, or team size exceeds 12 users. For a 20-person team, $1,440 annually provides integrations, epics, dashboards, and time tracking — less expensive than engineering effort to build workarounds. **Strategic positioning**: While the free tier remains legitimately functional, treating integrations as a premium feature represents deliberate growth leverage, compelling expansion once external workflow connections become essential. --- # Beton Product Newsletter > Major release: simplified onboarding, Firecrawl integration, MCP support for AI agents, Intercom support, and a complete visual overhaul with neo-brutalist design. *Source: [https://www.getbeton.ai/blog/beton-product-newsletter/](https://www.getbeton.ai/blog/beton-product-newsletter/)* **Published:** 2026-02-25 **Author:** Vlad Nadymov Major release featuring multiple significant updates to Beton. ## Neo-Brutalist Design Overhaul The application now features a consistent visual design throughout, matching the aesthetic previously seen only on landing pages. This creates a unified experience rather than a generic dashboard with branded marketing pages. ## Firecrawl Integration Users can now connect Firecrawl instances to enhance their data context. The platform supports both personal API keys and cloud-based options via the Settings panel. This enables the AI agent to: - Review company website content directly - Cross-reference site information with product usage data - Provide more comprehensive intent signals ## Demo Mode & Improved Onboarding The redesigned flow addresses user confusion by allowing visitors to explore the platform with demonstration data before commitment. Key improvements include: - No login, credit card, or initial configuration required - Demo mode clearly labeled throughout - Login available on every screen - Six-step setup wizard covering integrations, field mapping, domain configuration, and billing ## MCP Server Integration Inspector now includes an 18-tool Model Context Protocol server enabling AI agents to interact with the platform. The settings interface provides four sections: setup instructions, method documentation, active session monitoring, and request logging. ## Navigation Restructuring The sidebar evolved from a flat list to a hierarchical structure with collapsible sections for Memory, Settings, and other categories. State persists across sessions, and deep-linking automatically expands relevant sections. ## Additional Updates - Fixed agent-linked display issues - Added Intercom chat support for website visitors - Bug fixes for agent data model integration ## What's Next - Custom signal creation with PostHog event picker - Unified detection cron job refactoring - Slack as a signal destination - PostHog insights integration for agents --- # Firecrawl Pricing Teardown > Firecrawl has one of the smartest GTM setups in open source. The trick isn't in the pricing page — it's in the licensing. *Source: [https://www.getbeton.ai/blog/firecrawl-pricing-teardown/](https://www.getbeton.ai/blog/firecrawl-pricing-teardown/)* **Published:** 2026-02-18 **Author:** Vlad Nadymov Hey, it's Vlad, founder of Beton. I've had a habit of writing on pricing of COSS (commercial open source software) companies. Want to bring it back to life. First one is Firecrawl. Firecrawl has one of the smartest GTM setups I've seen in open source. The trick isn't in the pricing page — it's in the licensing. *This post is a part of series on commercial open source software pricing.* ## What is Firecrawl Firecrawl is a web scraping API that turns websites into LLM-ready markdown or structured data. Think of it as the plumbing layer between "the internet" and your AI agent — it handles proxies, JavaScript rendering, anti-bot bypasses and gives you clean output. They've raised from Y Combinator and are growing fast in the AI tooling space. ## The licensing play This is where it gets interesting. Firecrawl doesn't have one product — it has two, with very different licenses. **The core scraping engine is AGPL-3.0** You can self-host it, sure. But AGPL means that if you wrap it into your product and serve it to users, you have to open source your entire codebase. So competitors can't just take Firecrawl and build their own UI on top. And even if you self-host it just for internal use — good luck juggling rotating proxies, headless browsers and anti-bot detection at scale. That's the hard part. That's what you're actually paying Firecrawl for when you buy their cloud. **Fire Enrich (and many other Firecrawl-based tools) are MIT** This is their data enrichment tool — 650+ stars, fully open, do whatever you want with it. You could fork it and build a competing product tomorrow. But here's the thing: Fire Enrich is basically a collection of small system prompts that call GPT and tell it to go scrape the web for company data. Each "agent" is a thin wrapper. So when you use it, you end up paying Firecrawl for scraping infrastructure and OpenAI for tokens. The MIT license is generous because the product is a funnel, not a moat. Smart. Really smart. ## Pricing structure Firecrawl uses credit-based pricing: 1 page scraped = 1 credit. **Scrape & Crawl plans:** - **Free** — 500 credits, no credit card required. Enough to test - **Hobby** — $16/month for 3,000 credits (~$0.005/page) - **Standard** — ~$83-99/month for 100,000 credits + 50 concurrent browsers - **Growth** — $333/month for 500,000 credits + 100 concurrent browsers - **Enterprise** — custom pricing, sales call But here's what catches people off guard: the AI extract feature is a completely separate subscription. It runs on tokens, not credits. Starts at $89/month. So if you thought your Standard plan covers everything — it doesn't. You need two subscriptions to use the full product. **Extract plans (separate):** - **Starter** — $89/month - **Explorer** — $359/month - **Pro** — $719/month Lower-tier plans also cap crawls at 50 pages, which gets painful fast if you're scraping anything with depth — docs, catalogs, archives. ## Does it make sense to pay? Almost certainly yes, if you're building AI agents that need web data. Self-hosting Firecrawl is technically possible but practically painful. Web scraping at scale is an infrastructure nightmare — you need proxy rotation, browser pools, retry logic, anti-detection. This is the kind of thing where "just run a Docker" doesn't cut it. Unlike ClickHouse or Metabase where the self-hosted version is genuinely usable, Firecrawl's value *is* the managed infrastructure. The real question is whether the cost per contact makes sense for enrichment use cases. When you use Fire Enrich, you're not buying a database lookup at fractions of a cent. You're scraping live web pages and running LLM inference on every single query. That adds up fast — scraping credits + OpenAI tokens per contact. For high-volume enrichment (think Clay or Apollo scale), this could get expensive compared to traditional data providers that pre-crawl and cache everything. Firecrawl's bet is that freshness beats cheapness. Instead of stale database records, you get real-time data every time. Whether that tradeoff works depends on your volume and how much you care about data being current vs. data being cheap. --- # Shipped the Agent and New Website > Launched the full agent with demo, updated navigation in the app, and released our new website built on Astro. *Source: [https://www.getbeton.ai/blog/shipped-the-agent-and-new-website/](https://www.getbeton.ai/blog/shipped-the-agent-and-new-website/)* **Published:** 2026-02-11 **Author:** Vlad Nadymov We shipped a major update — launched the full agent with demo, updated navigation in the app, and released our new website. ## Agent Capabilities The newly launched agent automatically analyzes business infrastructure when users connect PostHog, Attio, and payment methods. Its functions include: - Studying websites to identify business models and pricing structures - Querying data warehouse table structures via API - Determining table relationships for analysis - Generating SQL queries that function as statistical tests - Running correlation analysis between patterns and metrics - Displaying findings in the interface ## New Features **Memory Page**: The agent stores learned business intelligence on a `/memory` page, consolidating pricing model, data structure, and business logic discoveries. **Navigation Updates**: Inspector received menu refinements with separate pages, corrected icons, and nested organization. **Support Integration**: Intercom's hooked up for support. Questions? Weird behavior? Need a refund? Just open the chat. **Website Rebuild**: We migrated from Webflow to Astro with markdown-based editing, Vercel hosting, and added use cases and competitor comparisons. ## What's Next - Agent UI integration (February 13) - Configurable statistical tests (February 20) - CRM field mapping and signal discovery automation --- # Billing Live, Agent Wiring & First Real Signups > 7 MVP signups, Stripe billing live, PostHog and Attio integrations operational, and agent wiring in progress with session-level authorization. *Source: [https://www.getbeton.ai/blog/billing-live-agent-wiring/](https://www.getbeton.ai/blog/billing-live-agent-wiring/)* **Published:** 2026-02-04 **Author:** Vlad Nadymov ## What's Going On We've scored and emailed 700 B2B leads, with 60 conversations resulting in a $90K qualified pipeline from cold outreach. We now have 8 letters of intent plus paying customers, 110 newsletter subscribers, and 216 LinkedIn followers. 7 MVP signups and we're monitoring user behavior through PostHog. ## Billing & Onboarding Live We launched Stripe integration with streamlined billing. Customers connect PostHog, add payment information, and hook up Attio with minimal friction. Self-hosted users need only one environment variable to access the full application without billing screens. Unlike competitors charging $30K+ annually upfront, Beton uses monthly pricing based on tracked users — significantly more affordable for early-stage PLG companies on an ACV basis. ## PostHog and Attio Integrations Both integrations are now operational. The system works by having customers connect PostHog during signup. Beton examines table structures via API without accessing raw data. The agent crawls client websites, generates SQL queries executed through PostHog's API, and automatically creates deals in Attio when signals trigger. ## Agent Wiring in Progress A demo mode is under development for users wanting to explore without immediate payment. We're building the API layer connecting Inspector (the UI connecting to data warehouses) and the Agent (built on Google ADK). Inspector provides website URLs while the Agent studies them and explores data through Inspector rather than direct database access, then constructs SQL pipelines that Inspector executes. Session-level authorization is being implemented to prevent cross-client data access. ## Lead Automation Workflow The process flows: signup via Supabase -> email to Clay -> Apollo enriches data -> JSON packaging for n8n -> Attio creates company, person, and deal automatically with zero manual intervention. --- # We Rebuilt Beton: Automated Signal Discovery > Complete product pivot toward automated signal discovery for PLG sales teams. The system analyzes data warehouses, runs statistical tests, and creates CRM deals when signals fire. *Source: [https://www.getbeton.ai/blog/we-rebuilt-beton-automated-signal/](https://www.getbeton.ai/blog/we-rebuilt-beton-automated-signal/)* **Published:** 2026-01-22 **Author:** Vlad Nadymov ## The Problem Product-led growth companies accumulate substantial first-party data — product usage events, billing records, CRM history, support tickets, and customer attributes. Yet extracting meaningful signals from this data proves difficult. Revenue and sales teams typically depend on intuition: "visited pricing page 3+ times" or "invited 2+ team members." While reasonable-sounding, these rarely predict conversion reliably. Sales teams are usually last in line for dedicated analysts, and seed or Series A companies lack budget for this role. Sales operations teams work without proper tools for discovering product-qualified leads. Consequently, inbound representatives spend significant time on leads unlikely to convert, wasting approximately 80% of their capacity — representing lost salaries and missed opportunities. ## What We Built Beton integrates with PostHog data warehouses to identify patterns predicting account expansion. The system validates patterns against historical conversion data by executing thousands of SQL queries, automatically tracking them, and creating new deals in your CRM when signals activate. The distinguishing factor: rather than monitoring manually-defined signals, Beton discovers signals you weren't aware existed. ### 1. Data Schema Analysis An AI agent examines your data warehouse schema and generates hypotheses about potential expansion signals, including product usage patterns, billing changes, support ticket content, and cross-attribute combinations. ### 2. Statistical Testing The system runs thousands of statistical tests through your data warehouse API. Only aggregated test results are retrieved — never raw customer data — preserving sensitive information in your infrastructure while enabling comprehensive analysis. ### 3. CRM Integration When an account triggers a validated signal, Beton creates a deal record in your CRM with context explaining why the account qualified, providing sales representatives actionable leads instead of guesswork. ## How It Works Beton's Inspector interface sits atop your PostHog data warehouse, querying data via PostHog's Query API. Even in the cloud version, row-level data access is prohibited — only aggregated query results are utilized. The agentic system, built with Google ADK, deploys multiple agents with distinct toolsets and objectives to analyze signal data comprehensively while remaining robust to varying user data schemas and business practices. Self-hosted versions allow users to provide their own API keys. Future iterations will enable self-hosters to use the agent via API, allowing Beton's agent to direct the locally-hosted Inspector with all queries executing on-premise, with the agent receiving only test results. ## Deployment Options The codebase will be released on GitHub (ensuring both agent and frontend function properly from a single Docker container). Self-hosting is complimentary when you supply your own LLM API keys. The cloud version costs $0.5 per tracked user monthly with monthly billing. Customer data remains in your warehouse — only statistical aggregates are received. ## What's Next Pilot customer onboarding begins in Q1 2026. Organizations using PostHog as a data warehouse with inbound sales operations are the target market. Planned features include backtesting to validate signals against historical data and continuous monitoring detecting when signals lose effectiveness as cohorts evolve. --- # November 2025 Update > Experiment with AI-assisted weekly updates. SEO work with 100+ integration pages, GitHub scraper development, and strategy thinking. *Source: [https://www.getbeton.ai/blog/november-2025-update/](https://www.getbeton.ai/blog/november-2025-update/)* **Published:** 2025-11-25 **Author:** Vlad Nadymov The weekly updates start to become a chore. I didn't keep up with the pace I set — and I constantly think "oh, I'd better write one more email instead of a new issue newsletter." So, I'll experiment with writing them with GPT. It checks my emails and calendar and summarizes whatever I did last week, then I rewrite it and send to you. ## SEO chores This week I mostly did free manual labor for Google. I added 100 integration pages to Beton's site, repeating Zapier's old trick of "one page per integration" to hoover up low-volume but unreasonably warm search traffic. Webflow CMS let me spit out 150 template-based pages from CSV, so ChatGPT wrote the HTML/CSS and templates, Claude rewrote the copy, and I just played the role of slightly confused content ops. On the technical SEO side I wired in ostr.io prerenders, so Googlebot now gets pre-cooked HTML from data centers sitting next to it — basically *Flash Boys*, but for indexing instead of HFT. I also sprinkled internal links everywhere via Webflow Collection lists, added PostHog tracking on the new pages, poked at Cloudflare Workers, and fought with sitemaps + robots.txt across the nice little Frankenstein of Webflow + Substack + Cloudflare. ## GitHub scraper In parallel I sketched a separate GitHub "scraper as a product" idea. A Streamlit app that eats a repo URL, respects rate limits, and slowly harvests contributors/issues into enrichment flows instead of me crying over 5k calls/day. The temptation is to distribute it via AGPLv3 so nobody uses it as part of their product. At the same time, this will spoil our codebase if the scraper becomes an integral part of Beton which I'd love to avoid. ## Wrapping up There was also some thinking about salestech market size, Clay + Apollo pricing gymnastics, and how Beton's lead form enrichment should sit between random web forms and CRMs without everyone hating it. Now I wait a week to see if any of this actually moves traffic, or if I just built a very expensive shrine to long-tail SEO. --- # New Apollo Integration & Faster Enrichment > Full-time founder commitment, $5.2K booked revenue, 40 inbound signups, webhook implementation, advisory board formation, and enterprise fintech deal pipeline. *Source: [https://www.getbeton.ai/blog/new-apollo-integration-faster-enrichment/](https://www.getbeton.ai/blog/new-apollo-integration-faster-enrichment/)* **Published:** 2025-11-06 **Author:** Vlad Nadymov ## Company Updates I've transitioned to full-time work on Beton. Also in discussions with two potential co-founders for COO and CTO positions. ## Traction $5,200 in new revenue, bringing total to $5,570. However, most recent revenue stems from consulting-style GTM work with startup customers — not ideal for our enterprise-focused direction. The cloud version has attracted 40 inbound signups with 1-3 demo requests weekly, though primarily from smaller companies rather than enterprise targets. ## Product Development We're implementing inbound and outbound webhooks to transform Beton tables into APIs. This capability will allow users to: - Receive new data from lead forms or n8n workflows - Enrich information automatically - Export results to Salesforce, email sequencers, or Google Sheets Bug fixes are targeted for mid-November completion. ## Strategic Initiatives **Advisory Board**: Building relationships with established sales leaders, offering equity stakes in exchange for bi-weekly consulting hours over two years. **Sales**: Preparing an enterprise fintech deal while validating pain points. Cold outreach is expanding to approximately 1,000 qualified accounts. **Fundraising**: Starting Friends, Family, and Fools fundraising mid-November, seeking $100K to fund paid enterprise pilots. Using SAFEs with lower caps for earlier investors.