The smart home landscape is finally growing up. After years of cloud-dependent gadgets that turn into expensive paperweights when your internet hiccups, 2026 marks the year when true local control becomes the default—not the exception. For DIY integrators who’ve spent countless hours wrestling with undocumented APIs, rate-limited cloud calls, and the sinking feeling of a “smart” device that’s anything but when the Wi-Fi drops, this shift isn’t just refreshing—it’s revolutionary.
Offline APIs are the secret sauce behind this transformation. These local network interfaces let your controller talk directly to devices without begging permission from a distant server, enabling sub-100ms response times, ironclad privacy, and automation that works even when your ISP doesn’t. Whether you’re building a modest apartment setup or orchestrating a 200-device estate, understanding what separates a robust offline-first controller from a glorified cloud relay will make or break your integration success. Let’s dive into the technical and strategic considerations that matter most for 2026’s DIY smart home architects.
Top 10 Smart Home Network Controllers with Offline APIs
 | Amcrest 4MP Video Doorbell Camera Pro, Outdoor Smart Home 2.4GHz and 5GHz Wireless WiFi, Micro SD Card, AI Human Detection, IP65 Weatherproof, 2-Way Audio, 164º Wide-Angle Wi-Fi AD410 | Check Price |
Detailed Product Reviews
1. Amcrest 4MP Video Doorbell Camera Pro, Outdoor Smart Home 2.4GHz and 5GHz Wireless WiFi, Micro SD Card, AI Human Detection, IP65 Weatherproof, 2-Way Audio, 164º Wide-Angle Wi-Fi AD410
Overview: The Amcrest AD410 is a hardwired video doorbell that delivers crisp 2K (4MP) resolution through an extra-wide 164° lens. It requires existing 16V-24V doorbell wiring and integrates with traditional mechanical or digital chimes. The IP65 weatherproof rating ensures reliable outdoor performance, while dual-band WiFi support provides flexible connectivity options for modern smart homes.
What Makes It Stand Out: This doorbell distinguishes itself with simultaneous 2.4GHz and 5GHz WiFi support, ensuring more stable streaming than single-band alternatives. The AI-powered human detection intelligently filters out false alerts from animals, vehicles, and moving branches. Crucially, local MicroSD storage (up to 128GB) lets you avoid mandatory cloud subscriptions entirely, while RTSP stream compatibility enables integration with third-party security systems for advanced users.
Value for Money: At $149.99, the AD410 significantly undercuts competitors like Ring and Nest while offering superior 2K resolution and genuine storage flexibility. The lack of required monthly fees makes it more economical long-term, though you’ll need to purchase a MicroSD card separately. The hardwired design eliminates battery replacement costs but may require professional installation if your home lacks existing doorbell wiring.
Strengths and Weaknesses: Strengths include exceptional video quality, intelligent AI detection, reliable dual-band WiFi, versatile storage options, and lifetime technical support. Weaknesses are the hardwired-only design (no battery backup), absence of an included MicroSD card, limited compatibility with Amcrest’s own cloud services, and potential non-NDAA compliance concerns for security-sensitive buyers.
Bottom Line: Perfect for homeowners wanting high-resolution video without subscription fees who already have compatible doorbell wiring. The AI detection and dual-band WiFi are compelling advantages, but those needing battery power or seamless cloud integration should consider alternatives.
Understanding Offline APIs in Smart Home Controllers
The Critical Role of Local Control for DIY Projects
Local control isn’t just about convenience—it’s about sovereignty. When you’re integrating disparate devices from multiple manufacturers, an offline API gives you a universal translation layer that operates entirely within your network. This means your custom automation scripts, Node-RED flows, or Home Assistant configurations continue functioning regardless of external factors. For DIY integrators, this translates to reliable trigger-response chains, predictable latency for time-sensitive operations like security alerts, and the ability to debug issues without wondering if it’s “just a server problem.”
How Offline APIs Differ from Cloud-Dependent Systems
Cloud-dependent controllers act as middlemen, relaying every command through external infrastructure. Offline APIs flip this model by exposing endpoints directly on the local network—typically via REST, WebSocket, or MQTT protocols. The key difference lies in discovery and authentication: offline-first controllers use mDNS/Bonjour for zero-configuration networking and often support API key generation through a local web interface, eliminating the need for OAuth flows that require internet connectivity. This architectural shift fundamentally changes how you’ll structure your automations, moving from polling-based to event-driven designs that consume far less network bandwidth.
Key Terminology: LAN API, Local Webhook, and Edge Endpoints
Before diving deeper, let’s clarify the jargon. A LAN API refers to any programmable interface accessible on your local network—this is your bread and butter. Local webhooks are HTTP callbacks triggered by the controller to other devices on your network, enabling push-based automation without constant polling. Edge endpoints represent the latest evolution: compute-capable nodes that process data locally before exposing refined results via API. Understanding these terms helps you evaluate vendor documentation and community discussions with precision.
Why 2026 is a Watershed Year for DIY Integration
Matter 2.0 and the Push for True Interoperability
Matter 1.0 was promising but incomplete; Matter 2.0 in 2026 finally delivers on the local-control promise with mandatory offline API support for certified devices. This means controllers can now query device capabilities, subscribe to state changes, and issue commands using standardized Matter clusters without touching the cloud. For DIY integrators, this eliminates the guesswork of reverse-engineering protocols. However, the specification still allows vendor-specific extensions, so your controller’s ability to expose these custom clusters via its own offline API becomes a critical differentiator.
Evolving Privacy Regulations Shaping Hardware Design
GDPR’s evolution and new state-level privacy laws in the US are forcing manufacturers to minimize data exfiltration. 2026’s controllers are designed with privacy-by-default principles, often featuring physical switches to disable all cloud connectivity while maintaining full API functionality. This regulatory pressure means vendors are finally documenting their offline APIs properly—no more hunting through GitHub issues for endpoint definitions. Look for controllers that publish OpenAPI specifications for their local interfaces; this indicates serious commitment to DIY integration.
The Rise of Edge Computing in Residential Applications
The line between smart home controller and edge server is blurring. Modern controllers ship with enough processing power to run lightweight AI models for voice processing, computer vision, and predictive automation locally. This shift means your API calls can trigger complex, multi-stage workflows entirely on-device. When evaluating controllers, assess not just API response times but also the available compute headroom for your own containerized applications—because in 2026, your controller is also your application server.
Core Hardware Architecture Decisions
Hub vs. Gateway vs. Full Controller: Understanding the Spectrum
Hub devices are radio aggregators—they translate Zigbee, Z-Wave, and Thread to IP but offer minimal local API sophistication. Gateways add protocol routing intelligence and basic automation engines. Full controllers are complete compute platforms with robust offline APIs, local storage, and development environments. For serious DIY integration, skip hubs entirely. Gateways work for simple setups, but full controllers give you the API depth and customization options that make complex projects feasible.
Processor Architecture: ARM Cortex-A78 vs. x86 Efficiency
ARM processors dominate the controller space for good reason: they’re power-efficient and generate less heat. The Cortex-A78 cores found in 2026’s mid-range controllers offer plenty of punch for API serving and automation. x86-based controllers (typically Intel Atom or AMD Embedded) provide better compatibility with legacy software but consume more power and require active cooling. For most DIY projects, ARM is the sweet spot—especially when you need 24/7 operation without a datacenter-grade UPS.
RAM and Storage: Minimum Specs for 2026 Workloads
Don’t settle for less than 4GB of RAM; 8GB is the practical minimum for running a modern controller with multiple API consumers, a local database, and a few containers. Storage-wise, 32GB of eMMC is the absolute floor, but you’ll want NVMe or at least quality eMMC (MLC, not TLC) for longevity. Controllers that support storage expansion via M.2 slots offer crucial flexibility—your API logs and time-series data will grow faster than you expect.
API Protocol Deep Dive for Technical Integrators
RESTful APIs: Best Practices for Local Network Implementation
A well-designed RESTful API for local use supports HTTPS with self-signed certificates (properly documented for trust installation), implements ETags for caching, and provides proper status codes. Look for HATEOAS (Hypermedia as the Engine of Application State) support, which lets your automation discover available actions dynamically. Rate limiting should be configurable or disabled entirely for trusted IP ranges. The best controllers expose their entire REST API via both IPv4 and IPv6, with mDNS advertisement for discovery.
WebSocket vs. Server-Sent Events for Real-Time Automation
WebSockets provide bidirectional communication—perfect for receiving device events while sending commands over the same connection. Server-Sent Events (SSE) offer simpler server-to-client streaming with automatic reconnection. For DIY integration, prioritize controllers that support both: use WebSockets for your primary automation engine and SSE for lightweight dashboards. Check the WebSocket subprotocol documentation; some controllers implement custom protocols for efficient binary data transfer that beats JSON over REST.
MQTT v5.0 Features to Look For
MQTT v5.0 brings shared subscriptions, topic aliases, and user properties that dramatically improve large-scale integration. Your controller should function as a full-featured MQTT broker (not just a client) with v5.0 support. Shared subscriptions let multiple automation instances load-balance message processing—a game-changer for redundancy. Topic aliases reduce bandwidth for frequently-published messages. Verify that retained messages survive controller reboots and that the broker supports persistent sessions for reliable delivery.
CoAP and gRPC: Emerging Protocols for IoT Efficiency
For ultra-low-latency scenarios, some 2026 controllers expose CoAP (Constrained Application Protocol) interfaces alongside HTTP. CoAP’s UDP-based design reduces overhead for simple queries. gRPC, with its strongly-typed schemas and HTTP/2 transport, excels for complex automation where you need strict API contracts. While not yet universal, controllers offering these alternatives signal engineering maturity and provide you with protocol choices that match your specific performance requirements.
Network Connectivity and Radio Stacks
Ethernet Backhaul: Gigabit vs. 2.5GbE for Future-Proofing
Wi-Fi is convenient, but Ethernet is mandatory for reliable controller operation. In 2026, 2.5GbE ports are becoming standard on premium controllers, and they’re worth the investment. Your offline API calls generate minimal traffic, but local camera streams, backup operations, and firmware updates can saturate gigabit links. More importantly, 2.5GbE often indicates a more robust internal bus design. Ensure the controller supports Energy-Efficient Ethernet to reduce power consumption during idle periods.
Tri-Radio Coexistence: Thread, Zigbee, and Z-Wave
The best controllers integrate three separate radios rather than using combo chips that share antennas. This provides cleaner spectrum utilization and lets you run all three protocols simultaneously without performance degradation. For Thread (critical for Matter), verify it supports the full 802.15.4 channel set and can function as a Thread Border Router with configurable network parameters. Zigbee should support source routing for large meshes, and Z-Wave needs SmartStart and S2 security. The controller’s API should expose radio diagnostics—RSSI, LQI, and routing tables—for troubleshooting.
VLAN Support for Network Segmentation
Serious DIY integrators segment IoT devices onto separate VLANs. Your controller must support 802.1Q VLAN tagging on its Ethernet interface, allowing it to bridge multiple VLANs while keeping traffic isolated. The API should respect these boundaries—letting you specify which VLAN an API endpoint binds to, for instance. Some controllers even support multiple IP addresses on different VLANs, enabling fine-grained firewall rules that protect your primary network while keeping APIs accessible to automation servers.
VPN Server Integration for Remote Access
While offline APIs work locally, you still need secure remote access. Controllers with built-in WireGuard or OpenVPN servers let you tunnel into your network without exposing APIs to the internet. The API should expose VPN connection status and allow automation based on which devices are connected remotely. This is crucial for geofencing alternatives that don’t rely on cloud location services—your phone connects to VPN, and your API-driven automation knows you’re home.
Security Frameworks in Offline-First Systems
Zero-Trust Network Access (ZTNA) for Local Controllers
Even on your LAN, assume breach. ZTNA principles mean every API call requires authentication, regardless of origin. Look for controllers that implement mutual TLS (mTLS) where both client and server present certificates. Some advanced units support SPIFFE/SPIRE for dynamic workload identity—overkill for most homes but essential if you’re running microservices. The controller should log all API access attempts locally, with tamper-evident storage for security events.
Certificate Authority Management and PKI
Managing certificates for dozens of API clients is painful. Quality controllers include a local Certificate Authority (CA) that auto-issues short-lived certificates to trusted devices. The API should expose ACME protocol support (like Let’s Encrypt but local) for automated certificate renewal. This eliminates manual certificate management while maintaining trust chains. Verify the controller’s CA root certificate can be exported for installation in your automation server’s trust store.
API Authentication Methods: JWT, OAuth 2.0, and mTLS
JWT (JSON Web Tokens) with local validation is the 2026 standard for stateless API authentication. OAuth 2.0 support (with a local authorization server) enables granular scope-based permissions—letting you issue tokens that can only control lights, for example. mTLS provides the strongest security for server-to-server automation. The best controllers support all three, letting you choose the right method for each integration. Check token lifetimes are configurable and that refresh token rotation is supported.
Secure Boot and Firmware Signing Requirements
Your controller’s offline API is useless if malware compromises the firmware. Secure Boot with hardware root of trust ensures only vendor-signed firmware runs. For DIY integrators, the key question is: does the controller allow you to add your own signing keys? Some open-friendly controllers let you enroll custom keys, enabling you to build and sign your own firmware while maintaining Secure Boot integrity. This is the holy grail for advanced tinkerers.
Data Management at the Edge
Local Database Architecture: SQLite, InfluxDB, or PostgreSQL?
APIs are only as good as the data they expose. Controllers using SQLite are fine for basic state storage but choke on time-series data like power consumption metrics. InfluxDB integration is ideal for sensor data, offering built-in downsampling and retention policies. PostgreSQL support indicates enterprise-grade design with proper transaction handling. The best approach? Controllers that let you choose and expose database access via API—so your custom dashboards can query directly without API middleware overhead.
Storage Media Durability: eMMC vs. NVMe vs. SD Card
SD cards are failure-prone and unsuitable for 24/7 logging. eMMC quality varies wildly; insist on controllers with wear-leveling information exposed via API so you can monitor lifespan. NVMe offers the best endurance and performance but consumes more power. For DIY projects, eMMC with at least 3000 P/E cycles (MLC or better) is the practical minimum. Some controllers implement RAM disks for high-write data, persisting to storage periodically—this dramatically extends flash lifespan and is a hallmark of well-engineered systems.
Backup and Disaster Recovery Strategies
Your API configurations represent hundreds of hours of work. Controllers should expose complete configuration backups via API (not just through a web UI) in a documented format. Look for automated backup to local NAS via SFTP, S3-compatible storage, or rsync. The restore process should be API-driven too, enabling infrastructure-as-code approaches. Some controllers support atomic snapshots—backing up both configuration and current device states, so recovery doesn’t trigger a wave of state-change automations.
Power and Physical Installation Considerations
Power over Ethernet (PoE++) for Clean Installations
PoE++ (IEEE 802.3bt) delivers up to 90W, powering even high-end controllers with NVMe storage and multiple radios. This eliminates wall warts and enables central UPS backup. The API should expose PoE negotiation status and power draw—useful for monitoring and automation. For example, you could script a controlled shutdown if the PoE switch reports low UPS battery. Verify the controller supports LLDP (Link Layer Discovery Protocol) to communicate power requirements to the switch.
Uninterruptible Power Supply (UPS) Communication Protocols
A controller that doesn’t know it’s on battery power can’t shut down gracefully. Look for USB HID UPS support (like apcupsd) or network UPS tools (NUT) integration. The API should expose UPS status variables—battery percentage, estimated runtime, power quality—so your automation can shed non-critical loads during outages. Some advanced controllers even support Modbus or SNMP to communicate directly with enterprise UPS systems, enabling sophisticated power management strategies.
Thermal Design and Passive Cooling Benefits
Fans fail, and when they do, your controller throttles or crashes. Passive cooling through aluminum heatsink chassis is the gold standard for 24/7 reliability. The API should expose temperature sensors for CPU, storage, and radio modules. This lets you create cooling alerts or even trigger smart vent adjustments in your equipment closet. Controllers that run cool enough for passive design often use less power and last longer—a win-win for DIY installations.
Scalability and Performance Planning
Device Limitations and License Models
Some controllers artificially limit device counts or API call rates unless you pay subscription fees. For DIY integration, this is unacceptable. Look for controllers with no artificial limits—the only constraints should be hardware resources. The API should expose performance metrics: active connections, message queue depth, CPU load per radio. This transparency helps you plan upgrades before hitting real limits, not vendor-imposed ones.
Memory and Storage Expansion Options
Soldered RAM might be fine today, but tomorrow’s AI-powered automations will need more. Controllers with SO-DIMM slots let you upgrade. For storage, M.2 NVMe slots are essential—not just for capacity but for wear leveling and performance isolation. The API should report memory usage per service and storage I/O metrics, helping you identify bottlenecks. Some controllers support memory-mapped API responses, dramatically improving performance for high-frequency polling scenarios.
Storage Expansion: M.2 Slots and USB4 Performance
USB4 (40 Gbps) ports enable high-speed external storage for backups and logs, but M.2 slots are better for primary storage expansion. The API should expose SMART data for all storage devices, predicting failures before they happen. For DIY projects, consider controllers with multiple M.2 slots: one for the OS (NVMe) and another for data logging (SATA SSD for cost-effectiveness). This separation simplifies OS upgrades without data migration.
Development Environment and Customization Potential
SDK Availability and Community Support
A controller without a proper SDK is a black box. Look for officially supported Python, Node.js, and Go libraries with asynchronous support. The API documentation should include OpenAPI specs, Postman collections, and code examples. Community vitality matters: active GitHub repos, Discord channels with vendor participation, and regular hackathons indicate a healthy ecosystem. Some vendors offer emulator images for offline API development—letting you build and test automations without physical hardware.
Containerization Support: Docker and Kubernetes at the Edge
Running your own services alongside the controller’s core functions is a massive advantage. Controllers supporting Docker (or Podman for security-conscious users) let you deploy custom API gateways, data processors, or dashboards. Kubernetes support is emerging for multi-controller deployments. The API should expose container management endpoints—start, stop, logs, resource usage—so you can orchestrate everything through your home automation platform. This turns your controller into a true edge compute node.
Firmware Management in Air-Gapped Environments
Offline Update Mechanisms: USB, SFTP, or Local Repository
Internet-disconnected controllers need update options. USB drives with signed firmware packages are the baseline. Better controllers run a local firmware repository (accessible via SFTP or API) where you upload updates downloaded elsewhere. The API should expose version information for all components—radio firmware, OS packages, API schemas—and support staged rollouts where you update a test controller first. This is critical for DIY integrators managing multiple installations.
Version Compatibility Matrices and Breaking Changes
API versioning is non-negotiable. Controllers should maintain API v1 endpoints even after v2 release, with clear deprecation timelines. The documentation must include compatibility matrices showing which firmware versions support which API features. Look for changelog entries that explicitly flag breaking changes. Some controllers offer API compatibility modes—emulating older API behavior for legacy integrations while you migrate to new endpoints.
Rollback Procedures and Factory Reset Behavior
Failed updates shouldn’t brick your system. Controllers with dual firmware partitions enable instant rollback via API call. The factory reset behavior matters too: does it wipe only configuration or also API keys, logs, and custom scripts? Ideally, you want granular reset options exposed via API. Some controllers support “factory reset profiles”—pre-configured reset behaviors for different scenarios (e.g., “reset network but keep automations”).
Total Cost of Ownership Analysis
Hardware Cost vs. Subscription Models
A $300 controller with no subscription beats a $100 controller requiring $5/month forever. Calculate 5-year TCO including power consumption. The API should expose enough functionality that you never need a vendor’s cloud service. Be wary of “freemium” API features—some vendors lock advanced automation endpoints behind paywalls. For DIY, total local control is the only acceptable model.
Power Consumption: ARM Efficiency for 24/7 Operation
That x86 controller might be powerful, but at 30W vs. 5W for ARM, you’re looking at $40+ extra annually in electricity. The API should expose real-time power draw, letting you verify vendor claims. Some controllers implement dynamic power scaling—shutting down radios or reducing CPU frequency during quiet periods. This can be API-controlled, letting you optimize for performance during active hours and efficiency at night.
Hidden Licensing Fees for Advanced API Features
Read the fine print. Some controllers charge extra for MQTT broker functionality, API rate increases beyond “standard” levels, or access to radio diagnostic APIs. These nickel-and-dime tactics destroy DIY budgets. Look for controllers with transparent, one-time pricing and all features enabled out of the box. The vendor’s API documentation should never mark endpoints as “enterprise only” or “cloud-required.”
Future-Proofing Strategies for 2026 and Beyond
Edge AI/ML Accelerator Integration (NPU, TPU)
Neural Processing Units (NPUs) and Tensor Processing Units (TPUs) are appearing in premium controllers, enabling local voice recognition, gesture detection, and predictive maintenance. The API should expose these accelerators—letting you run your own models via ONNX Runtime or TensorFlow Lite. This transforms your controller from a simple API relay into an intelligent automation brain that learns your patterns without cloud training.
Wi-Fi 7 and 6G Readiness
While Wi-Fi 7 is just rolling out, your controller’s radio should support it, or at least have a clear upgrade path via USB4 or M.2 slots. More importantly, ensure the API abstraction layer doesn’t hardcode Wi-Fi assumptions. As 6G looms (with its terahertz frequencies and mesh capabilities), your automation should transition seamlessly. Controllers with software-defined radio (SDR) architectures offer the ultimate future-proofing, though at premium prices.
Matter Over Thread 2.0 Compatibility
Thread 2.0, expected late 2026, brings increased bandwidth and deterministic latency for industrial IoT features that will trickle down to smart homes. Your controller’s Thread radio should be firmware-upgradable to 2.0, and the API must expose new features like prioritized message channels. This matters for time-critical automations like security sensor triggers or lighting scenes where 50ms vs. 200ms response time is noticeable.
Frequently Asked Questions
1. What’s the difference between “offline API” and “local API”?
“Offline API” specifically means the interface remains fully functional without internet connectivity—no cloud authentication, no external DNS, no phoning home. “Local API” is a broader term that might still require initial cloud activation or periodic license checks. Always verify the controller works in an air-gapped environment before purchasing.
2. How do I discover a controller’s offline API endpoints without documentation?
Use network scanning tools like nmap to find open ports, then curl the root path to see if it returns an OpenAPI spec. Many controllers respond to mDNS queries for _hap._tcp or custom service types. Check community forums for reverse-engineering efforts, but prioritize vendors that publish official specs—undocumented APIs can break without notice.
3. Can I use multiple controllers with offline APIs in the same home?
Absolutely. Use a primary controller as your API gateway and treat secondary controllers as protocol bridges. Expose their APIs through the primary one using MQTT or REST proxying. This approach distributes radio load and provides redundancy. Ensure each controller uses a different mDNS name to avoid conflicts.
4. What’s the typical latency difference between cloud and offline API calls?
Cloud API calls typically range from 150ms to 800ms depending on internet and server load. Offline API calls on a local gigabit network consistently measure under 10ms, often as low as 2-3ms. For WebSocket events, latency is near-zero with immediate push delivery. This difference is critical for responsive lighting, audio sync, and security applications.
5. Do offline APIs support OAuth 2.0, or is it just API keys?
Most 2026 controllers support both. API keys are simpler for basic scripting, while OAuth 2.0 with a local authorization server enables granular permissions. For DIY use, start with API keys for quick prototyping, then migrate to OAuth for production automations where you need to restrict access by client type or function.
6. How can I monitor the health of my controller’s offline API?
Use the controller’s own API to expose metrics endpoints (Prometheus format is ideal). Monitor response times, error rates, and active connection counts. Set up local health checks that call a lightweight API endpoint every 30 seconds. Some controllers support SNMP, letting you integrate with traditional monitoring tools like Zabbix or LibreNMS.
7. Are offline APIs vulnerable to local network attacks?
Yes, which is why security matters. Always use HTTPS with certificate validation, implement mTLS for sensitive integrations, and segment IoT devices onto isolated VLANs. Change default API keys immediately and use strong, unique passwords for any basic auth endpoints. Regularly audit API logs for unusual access patterns.
8. Can I run my own custom API endpoints on the controller?
If the controller supports containers (Docker/Podman), you can deploy your own API services alongside the built-in ones. Some open-source controllers even let you modify the core API server. Check for documentation on reverse proxy configuration so your custom endpoints integrate seamlessly with the controller’s security model.
9. What happens to offline APIs during firmware updates?
Well-designed controllers maintain API availability during updates, either by updating components sequentially or running dual instances briefly. The API should return a 503 status with a Retry-After header during brief outages. Avoid controllers that require complete API downtime for updates—this breaks long-running WebSocket connections and disrupts automations.
10. How do I future-proof my API integrations against vendor changes?
Abstract vendor-specific APIs behind your own intermediate layer (e.g., Node-RED or a custom microservice). Use standardized data models internally, and only translate at the edges. Favor controllers with OpenAPI specs—this makes generating client libraries trivial if you need to switch vendors. Contribute to open-source abstraction libraries like Home Assistant’s integrations to share the maintenance burden with the community.