# The Definitive Guide to Reliably Working with Shopify Webhooks over HTTPS Using Hookdeck ## Introduction: Why Hookdeck for Shopify HTTPS Webhooks Shopify recommends that engineering teams use or build highly reliable and scalable webhook event ingestion infrastructure. This ensures they never miss an event and their platforms and businesses are not negatively impacted. For very high-volume workloads, Shopify highlights managed event buses like GCP Pub/Sub and Amazon EventBridge. These platforms offer durability and horizontal scale, but adopting those options usually means working with AWS or GCP and re-architecting how your application ingests and processes events. Many teams prefer to keep the simplicity, direct integration capabilities, and lower operational overhead of HTTPS webhooks. Shopify's [official HTTPS webhook guide](https://shopify.dev/docs/apps/build/webhooks/subscribe/https) outlines the production requirements for HTTPS delivery. These include secure endpoints, timely acknowledgements, strong signature verification, and queuing patterns. Across other documentation such as [Shopify webhook best practices](https://shopify.dev/docs/apps/build/webhooks/best-practices), Shopify outlines approaches to [duplicate detection](https://shopify.dev/docs/apps/build/webhooks/ignore-duplicates), [troubleshooting](https://shopify.dev/docs/apps/build/webhooks/troubleshooting-webhooks), and monitoring. The [Hookdeck Event Gateway](/event-gateway) gives you the best of both worlds. It provides the reliability and scale of a managed event platform while preserving the developer experience of HTTPS webhooks. An Event Gateway acts as an intermediary layer that receives, processes, and reliably delivers webhooks to your application, adding features like retry logic, monitoring, and deduplication. Hookdeck implements all of Shopify's HTTPS webhook production requirements. These include fast acknowledgements/connection handling, robust retry policies, deduplication, HMAC signature verification, HTTPS termination, and observability. It then extends them with production-ready controls. Hookdeck provides additional capabilities that reduce engineering effort and risk. These include a 60-second default delivery window, extended retry windows, configurable deduplication (recommended using Shopify headers), centralized signature verification, durable queues with dead-letter handling, searchable logs with event retention (up to 30 days), manual/bulk retries, routing and transformations for migrations or fan-out, rate limiting and traffic filtering, and granular monitoring and alerting. These features let teams continue using HTTPS webhooks while gaining the operational guarantees of a managed event bus. This guide shows step-by-step how to set up Hookdeck for Shopify HTTPS webhooks. You'll learn how to use these features to build production-ready integrations that satisfy, and extend, Shopify's reliability standards. ## Shopify's HTTPS Webhook Recommendations and Hookdeck's Solutions {#shopify-recommendations} Shopify's recommendations require building sophisticated retry systems, queues, observability infrastructure, and deduplication logic. Here's how Hookdeck addresses each requirement: | Shopify Recommendation | Why It Matters | Shopify's Default | How Hookdeck Helps | | --- | --- | --- | --- | | [Respond quickly](#timeout-flexibility) | Shopify expects a `200 OK` within 5 seconds or it retries. Slow endpoints risk duplicate deliveries and backlogs. | 5-second timeout before retry. | Hookdeck acknowledges immediately and gives your app a 60-second delivery window, reducing false retries during slightly longer processing. | | [Handle retries](#retry-policy-flexibility) | Prevents lost events if your app is down. | 8 retries over 4 hours; if all fail and subscription was created via Admin API, it's deleted. | Highly configurable retry policies, no subscription deletion risk, and retries continue beyond Shopify's limit until success or dead-lettered. | | [Prevent duplicates](#configurable-deduplication) | Shopify retries + network instability can cause duplicates, requiring idempotency. | No native deduplication. | Configurable deduplication detects and drops duplicates. For Shopify, using the `X-Shopify-Event-Id` header as the identifier is recommended. | | [Verify signatures](#simplified-signature-verification) | Ensures authenticity of payload. | Requires custom HMAC logic in your app. | Hookdeck verifies Shopify's signature for you (when you provide the webhook secret). Your app only needs to verify Hookdeck's own signature, one implementation works across multiple platforms. | | [Secure endpoints](#enhanced-security-and-filtering) | Prevent unwanted requests. | HTTPS only. | All traffic terminates over HTTPS. You can implement IP-based filtering using Hookdeck Transformations and Filters to drop unwanted requests before delivery. | | [Monitor and alert](#comprehensive-monitoring-and-alerting) | Spot failures early. | Basic delivery logs in Shopify admin. | Searchable logs with retention (up to 30 days), manual/bulk retries, metrics, and alerting from the Hookdeck dashboard. | | [Handle version changes](#api-version-migration-support) | API version changes can break parsing. | API version pinned at subscription creation. | Route events by version or topic; fan out to old/new consumers during migrations. | | | | | | ## How Hookdeck Improves on Shopify's Default HTTPS Webhook Behavior {#hookdeck-improvements} ### Persistent Queue and Reconciliation Why It Matters: Webhook reliability is fundamental to building robust e-commerce integrations. Any lost event could mean missed sales notifications, inventory updates, or customer actions that directly impact business operations. Shopify's Approach: While Shopify does implement a retry mechanism (8 retries over 4 hours with exponential backoff), events can still be missed. This happens if your endpoint remains unavailable throughout this entire window, or if the webhook subscription gets automatically deleted after consecutive failures. Additionally, during extended outages, events can pile up and overwhelm your system once it comes back online. Hookdeck's Solution: The Hookdeck Event Gateway implements a guaranteed ingestion model. It immediately acknowledges receipt from Shopify (preventing unnecessary retries), persists each event in a durable queue, and handles delivery to your application separately. This separation reduces duplicate processing, minimizes backlogs, and extends reliability beyond Shopify's ~4-hour retry window. ### Timeout Flexibility Modern applications often need more processing time than Shopify's standard timeout provides, especially when handling complex business logic, external API calls, or database transactions that can't be easily rushed. Why It Matters: Applications performing inventory synchronization, customer data enrichment, or third-party integrations frequently require more than Shopify's tight deadlines. These operations might involve multiple database queries, external service calls, or complex calculations. These simply cannot be compressed into such a narrow window. Shopify's Constraints: Shopify enforces strict timing requirements with a 1-second connection timeout (your server must accept connections within 1 second) and a 5-second total timeout for the entire request lifecycle. Any response taking longer triggers an automatic retry, regardless of whether your application is still successfully processing the original request. This creates unnecessary duplicate processing and can lead to race conditions. Hookdeck's Solution: Hookdeck provides a 60-second delivery window for your application. This gives legitimate processing more time than Shopify's 5-second limit. Because Hookdeck acknowledges Shopify immediately, your handler can complete within this window without triggering unnecessary Shopify retries. ### Retry Policy Flexibility Transient failures are inevitable in distributed systems, but losing webhook subscriptions due to temporary issues can disrupt business operations and require manual intervention to restore functionality. Why It Matters: Production applications face numerous failure scenarios: deployment downtime, database maintenance windows, network partitions, or temporary service degradation. These issues shouldn't result in permanent data loss or subscription termination, yet Shopify's retry policy has specific boundaries that can lead to these outcomes. Shopify's Approach: Shopify attempts ~8 retries over a ~4-hour window using exponential backoff. If your subscription was created via the Admin API and delivery repeatedly fails, Shopify may disable or delete the subscription. Notifications are sent to the Partner account's emergency developer email. Hookdeck's Advantages: The Hookdeck configurable [webhook retries functionality](/docs/retries) offers: * Subscription preservation — webhook connections remain active indefinitely, regardless of delivery failures * Flexible retry scheduling — choose exponential backoff, linear intervals, or custom timing that matches your application's recovery patterns * Extended retry windows — continue attempts far beyond Shopify's 4-hour limit * Dead letter handling — problematic events are flagged for investigation rather than discarded, ensuring no data is permanently lost > Note on Failed Event Management: Unlike traditional [dead letter queues](/webhooks/guides/dead-letter-queues-webhook-reliability) that move failed events to separate storage, Hookdeck keeps failed events in the same system with full observability and manual/bulk retry capabilities. This provides DLQ-like reliability while maintaining complete event recovery control. ### Configurable Deduplication Duplicate webhook processing can corrupt application state, trigger double charges, send multiple notifications, or create inconsistent data across systems. This makes [Deduplication](/docs/deduplication) (the configurable process of identifying and filtering out duplicate or noisy webhook events to ensure each event is processed only once) a critical but complex requirement for production applications. Why It Matters: Network instability, Shopify's retry logic, and application timeouts can all contribute to duplicate webhook deliveries. Without proper deduplication, your application might process the same order update multiple times. This leads to inventory discrepancies, duplicate customer notifications, or inconsistent analytics data. Shopify's Approach: Shopify provides no built-in deduplication mechanism. Developers must implement custom [idempotency](/webhooks/guides/implement-webhook-idempotency) logic in their applications. This typically involves using database constraints, caching layers, or complex state tracking across multiple webhook events. Hookdeck's Deduplication: Hookdeck can be configured to deduplication events before they reach your application. Configure the `X-Shopify-Event-Id` header as the deduplication key to ensure each unique webhook is processed once. This works regardless of how many times Shopify attempts delivery. Pair this with application-level idempotency for defense in depth. ### Simplified Signature Verification Webhook authenticity verification is essential for security, but implementing cryptographic signature validation across multiple programming languages and handling edge cases creates unnecessary development overhead and potential security vulnerabilities. Why It Matters: Without proper signature verification, your webhook endpoints are vulnerable to spoofed requests, replay attacks, and malicious payloads that could compromise application security or corrupt business data. However, implementing HMAC validation correctly requires careful handling of encoding, timing attacks, and various edge cases. Shopify's Requirements: Every application must implement custom HMAC-SHA256 signature verification using the app's client secret. This means writing cryptographic code, handling base64 encoding, managing secrets securely, and ensuring timing-safe comparison operations across different programming languages and frameworks. Hookdeck's Streamlined Approach: Hookdeck supports numerous methods of [source authentication](/docs/authentication#source-authentication). When you provide your webhook secret during connection setup, Hookdeck automatically verifies Shopify's signatures before forwarding events. Your application only needs to verify Hookdeck's own signature using its standardized approach, which works identically across all supported webhook platforms. This reduces implementation complexity while improving security consistency. ### Enhanced Security and Filtering Production webhook endpoints need sophisticated security measures beyond basic HTTPS to protect against malicious traffic, DDoS attempts, and unwanted requests that could impact application performance or security. Why It Matters: Public webhook endpoints are attractive targets for automated attacks, malicious bot traffic, and resource exhaustion attempts. Applications need granular control over which requests are processed and which are blocked before they consume server resources. Shopify's Basic Protection: The platform requires HTTPS for webhook delivery but provides no additional filtering, rate limiting, or traffic shaping capabilities. Your application endpoints are directly exposed to all incoming traffic. Hookdeck's Security Layer: Hookdeck terminates all traffic over HTTPS and provides: * IP allowlist/blocklist filtering using [Transformations](/docs/transformations) and [Filters](/docs/filters) to block suspicious traffic sources * Request rate limiting set a [delivery rate](/docs/destinations#set-a-max-delivery-rate) for your endpoints to prevent overwhelming your application * Content filtering using [Filters](/docs/filters) to block malformed or suspicious payloads ### Comprehensive Monitoring and Alerting Webhook failures can silently break critical business processes, making comprehensive observability essential for maintaining reliable integrations and quickly identifying issues before they impact customers. Why It Matters: When webhook processing fails, the effects often aren't immediately visible to end users but can cascade into significant business problems: missed order notifications, stale inventory levels, or broken automation workflows. Early detection and rich debugging information are crucial for maintaining system reliability. Shopify's Monitoring: The platform provides basic delivery logs in the admin dashboard showing success/failure status, offers focused debugging information, and sends warning emails to the Partner account's emergency developer email when subscriptions are failing. However, these alerts are limited to critical subscription-level issues rather than individual event failures. Troubleshooting webhook issues benefits from additional context and tools. Hookdeck's Observability: Hookdeck's monitoring platform includes: * Searchable event logs with full payload and metadata retention; search [requests](/docs/requests), and [events and attempts](/docs/events) for debugging * Real-time metrics tracking success rates, latency, and failure patterns. See [Metrics](/docs/metrics). * Manual and bulk retries for testing fixes against retained historical events. See [Retries](/docs/retries). * Customizable alerting via email, Slack, PagerDuty, and webhooks. See [Issues & Notifications](/docs/issues). Hookdeck retains requests, events, and delivery attempts for up to 30 days. During this period you can perform manual or bulk retries to support failure management and recovery workflows. See [Retries](/docs/retries) for details on retry limits, strategies, and APIs. ### API Version Migration Support Shopify's API evolution requires careful coordination between old and new webhook formats, making version migrations complex and risky without proper routing and gradual rollout capabilities. Why It Matters: When Shopify releases new API versions with different webhook schemas, applications must handle the transition carefully to avoid service disruption. The migration process often involves running multiple application versions simultaneously while gradually shifting traffic. Shopify's Constraints: Webhook subscriptions are locked to the API version at creation time, requiring applications to manage multiple subscriptions and handle different payload formats during migration periods. This creates complex coordination challenges. Hookdeck's Migration Tools: The routing system enables: * Version-based routing to direct webhooks to appropriate application endpoints based on API version using [Filters](/docs/filters) * Fan-out delivery to send the same webhook to multiple destinations during migration periods * Schema transformation to normalize different API versions into consistent formats using [Transformations](/docs/transformations) ## Step-by-Step: Setting Up Shopify HTTPS Webhooks with Hookdeck ### 1. Create a Hookdeck Account and Get API Key Sign up for a [Hookdeck Event Gateway account](https://dashboard.hookdeck.com) and obtain your project API secret from the dashboard under Settings → Secrets. ### 2. Create a Hookdeck Connection Create a [Connection](/docs/connections) that includes a Shopify [Source](/docs/sources) and an HTTP [Destination](/docs/destinations). First, get your Shopify app's client secret: Before creating the connection, you'll need your app's client secret for webhook signature verification. The Client secret is found the Overview section of your app within the Shopify Partner Dashboard (Home → Apps → YOUR APP → Client credentials → Client secret). Next, create a connection that maps the inbound events from Shopify to the endpoint that handles Shopify events. As part of this, you can set: * [Retry](/docs/retries) rule to control how Hookdeck retries failed deliveries to your endpoints * [Deduplication](/docs/deduplication) rule configuration to remove duplicate Shopify events from being delivered to your endpoints * [Destination rate limiting](/docs/destinations#set-a-max-delivery-rate) to control the flow of events and prevent overwhelming your application Here's how to create the connection: ### 3. Create Shopify Webhook with Hookdeck Source URL Use the source URL from step 2 to create your Shopify webhook. ### 4. Handle the Webhook and Verify Signatures With Hookdeck handling Shopify signature verification, your application only needs to verify Hookdeck's signature. This simplifies your code and provides a consistent verification method across all webhook platforms. ### 4. Test Shopify Webhooks Locally with Hookdeck CLI Forward events to your local development environment: Install the [Hookdeck CLI](/docs/cli). Login and listen for webhook events: ```bash # authenticate CLI hookdeck login # Forward events to local development server hookdeck listen 3000 shopify ``` Running `hookdeck listen` creates a second connection consisting of the Shopify Source and a new CLI Destination and allows you to test your webhook handling code locally without affecting your production environment. > CLI destinations do not support delivery rate limiting. #### Bookmark Events for Testing Use Hookdeck's [bookmarking feature](/docs/bookmarks) to save specific Shopify events for testing and debugging. When developing your webhook handlers, bookmark representative events (orders, customer updates, inventory changes) to create a library of test scenarios. This allows you to replay real Shopify payloads during development without triggering new events from your store. ### 5. Configure Webhook Delivery Alerts with Issue Notifications The Hookdeck Event Gateway will automatically create [Issues](/docs/issues) for failed webhook deliveries. You will receive email notifications whenever there are issues with your webhook deliveries. You can also configure issues notifications to: * Trigger webhooks * Create PagerDuty incidents For more information, see the [issue notifications documentation](/docs/issues). ### 6. Monitor and Analyze Shopify Events {#step-6} Monitor your Shopify webhook events to maintain integration health and quickly identify issues. #### Event Flow Overview Hookdeck processes webhooks through three stages: Request (initial HTTP from Shopify) → Event (processed webhook data) → Attempt (delivery tries to your endpoint). This flow helps trace issues from source to delivery. See [Events documentation](/docs/events) for details. #### Search and Filter Events Use the [Events dashboard](https://dashboard.hookdeck.com/events) to focus on Shopify-specific monitoring: Key Filters: * Status: `Failed`, `Successful`, `Pending`, `On hold` * Source: Select your Shopify connection * Time Range: Analyze specific periods * Headers: Filter by `X-Shopify-Topic` (event type) or `X-Shopify-Shop-Domain` (store) For advanced filtering and payload searches, see [Event filtering documentation](/docs/events#filterable-properties). #### Event Inspection Shopify Headers to Monitor: * `X-Shopify-Topic`: Event type (`orders/create`, `customers/update`) * `X-Shopify-Shop-Domain`: Source shop (useful for multi-store setups) * `X-Shopify-Event-Id`: Unique event identifier (used for deduplication) * `X-Shopify-API-Version`: API version used Common Issues: * 401/403: Authentication problems * Timeout: Exceeds 60-second delivery window * 5xx Errors: Application server issues * Connection Refused: Network connectivity problems #### Custom Views Create [custom event views](/docs/events#custom-event-views) for focused monitoring: 1. Navigate to [Events](https://dashboard.hookdeck.com/events) 2. Apply filters (e.g., Status: `Failed`, search for order-related webhooks) 3. Save as "Critical Shopify Events" For multi-store setups, create separate views filtered by `X-Shopify-Shop-Domain`. #### Key Metrics Monitor these essential KPIs on your [Sources](https://dashboard.hookdeck.com/sources), [Connections](https://dashboard.hookdeck.com/connections), and [Destinations](https://dashboard.hookdeck.com/destinations) pages: * Success Rate: Target >99% for critical webhooks * Response Latency: Benchmark <5 seconds * Volume Trends: Monitor "Events rate" for traffic patterns * Queue Depth: Watch "Pending events" for backpressure Set up issue triggers for automated alerts. For detailed metrics analysis, see [Metrics documentation](/docs/metrics). #### Best Practices Daily Monitoring: 1. Check failed events from overnight 2. Verify response times for critical webhooks (orders, payments) 3. Review error patterns Issue Response: 1. Inspect event details for root cause 2. Check if issues affect multiple events 3. Monitor recovery after fixes 4. Use [manual retries](/docs/retries) to test fixes For comprehensive monitoring strategies, see the [Observability guide](/docs/guides/how-to-gain-full-observability-of-your-event-flows). ### 7. Retry Shopify Events {#step-7} Retry events for errors discovered in production, or for testing and debugging: ## Advanced Shopify Webhook Patterns with Hookdeck {#advanced-patterns} ### Multi-Tenant Routing Route webhooks to different applications based on shop domain by creating multiple connections. Each connection uses a filter rule that identifies the shop domain. For example, to route webhooks from different Shopify stores to different destinations: Connection 1 - Premium Store: ```json { "x-shopify-shop-domain": "premium-store.myshopify.com" } ``` Connection 2 - Basic Store: ```json { "x-shopify-shop-domain": "basic-store.myshopify.com" } ``` Connection 3 - Enterprise Store with advanced filtering: ```json { "$and": [ { "x-shopify-shop-domain": "enterprise-store.myshopify.com" }, { "x-shopify-topic": { "$in": "orders" } } ] } ``` Each connection would have a different destination URL corresponding to the appropriate application instance for that tenant. The complete syntax for filters can be found in the [Filters documentation](/docs/filters). ### Fan-Out Pattern Send the same webhook to multiple destinations by creating multiple connections that use the same [Source](/docs/sources): ```bash # Create first connection curl -X POST "https://api.hookdeck.com/2027-07-01/connections" \ -H "Authorization: Bearer $HOOKDECK_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "name": "Shopify-to-App1", "source_id": "src_123abc", "destination": { "name": "App1", "type": "http", "config": { "url": "https://app1.com/webhooks" } } }' # Create second connection curl -X POST "https://api.hookdeck.com/2027-07-01/connections" \ -H "Authorization: Bearer $HOOKDECK_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "name": "Shopify-to-Analytics", "source_id": "src_123abc", "destination": { "name": "Analytics", "type": "http", "config": { "url": "https://analytics.com/webhooks" } } }' ``` ### Payload Transformation Shopify webhook payloads can be complex and contain more data than your downstream services need. Payload transformation allows you to optimize these webhooks for your specific use case. Key Transformation Benefits: * Simplify payloads: Remove unnecessary fields to reduce bandwidth and processing overhead * Standardize data formats: Convert Shopify's string prices to numbers for easier mathematical operations * Extract key information: Pull out only the essential data points your application needs * Ensure compatibility: Reformat payloads to match your existing API schemas * Add computed fields: Include derived values like order totals or customer segments Transform Shopify payloads before delivery: ```javascript // Simplify order payload for downstream services addHandler("transform", (request, context) => { const webhook = request.body; return { ...request, body: { "order_id": webhook.id, "customer_email": webhook.customer.email, "total": parseFloat(webhook.total_price), "currency": webhook.currency, "line_items": webhook.line_items.map(item => ({ "product_id": item.product_id, "quantity": item.quantity, "price": parseFloat(item.price) })) } }; }); ``` For more information, see [Transformations](/docs/transformations). ### Plan API Version Migrations Use multiple connections with a {ref entity="Filter"} based on the Shopify API version to handle API version upgrades: ```bash # Create connection for new API version curl -X POST "https://api.hookdeck.com/2027-07-01/connections" \ -H "Authorization: Bearer $HOOKDECK_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "name": "Shopify-to-App-v2", "source_id": "src_123abc", "destination": { "name": "App-v2", "config": { "url": "https://yourapp.com/webhooks/v2" } }, "rules": [ { "type": "filter", "filter": { "headers": { "x-shopify-api-version": "2024-01" } } } ] }' # Keep connection for legacy versions curl -X POST "https://api.hookdeck.com/2027-07-01/connections" \ -H "Authorization: Bearer $HOOKDECK_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "name": "Shopify-to-App-v1", "source_id": "src_123abc", "destination": { "name": "App-v1", "config": { "url": "https://yourapp.com/webhooks/v1" } }, "rules": [ { "type": "filter", "filter": { "headers": { "x-shopify-api-version": "2023-10" } } } ] }' ``` ### Implement Idempotency Even with [Deduplication](/docs/deduplication) enabled, implement idempotency in your application: ```js const processedEvents = new Set(); app.post('/webhooks/shopify', verifyHookdeckSignature, (req, res) => { const eventId = req.headers['x-hookdeck-eventid']; // Check if already processed if (processedEvents.has(eventId)) { console.log(`Event ${eventId} already processed, skipping`); return res.status(200).json({ success: true }); } // Process event processEvent(req.body); // Mark as processed processedEvents.add(eventId); res.status(200).json({ success: true }); }); ``` ## Conclusion and Next Steps {#conclusion} Hookdeck helps teams operate Shopify HTTPS webhooks reliably at scale. By implementing Shopify's recommended best practices, including deduplication, Hookdeck removes much of the complexity of building reliable webhook infrastructure from scratch. This comprehensive approach ensures your webhook system meets production requirements while providing the operational guarantees needed for business-critical integrations. ### Key benefits of using Hookdeck with Shopify webhooks * Zero webhook loss through persistent queuing and guaranteed ingestion * Configurable deduplication using Shopify's unique webhook event identifiers to prevent duplicate processing * Simplified signature verification with one implementation for all platforms * Extended processing time with 60-second delivery windows instead of Shopify's 5-second limit * Comprehensive monitoring and alerting for proactive issue resolution * Flexible retry policies that preserve webhook subscriptions and extend beyond Shopify's limits ### Next Steps 1. Start with the [setup guide](#setup-guide) to implement your first Shopify webhook connection 2. Explore [advanced patterns](#advanced-patterns) for multi-tenant routing and payload transformation 3. Implement [monitoring strategies](#step-6) to maintain system health and performance 4. Review [high-volume scenarios](#high-volume) for scaling your webhook infrastructure By following this guide, you'll have a production-ready Shopify webhook system that can handle your business requirements while providing the reliability and observability needed for long-term success. * Advanced retry policies that surpass Shopify's default behavior * Comprehensive monitoring and debugging tools for production operations * Flexible routing and transformation for complex integration patterns ### Ready to get started? 1. [Sign up for Hookdeck](https://dashboard.hookdeck.com) and create your first Shopify source 2. [Install the CLI](https://hookdeck.com/cli) for local development and testing 3. [Read the full documentation](https://hookdeck.com/docs) for advanced configuration options 4. [Join the community](https://hookdeck.com/slack) for support and best practice discussions With Hookdeck handling the reliability concerns, you can focus on building exceptional Shopify applications that scale with confidence.