Overview

The Local-First subscription runs the entire ET Ducky platform — API server, database, and web dashboard — on infrastructure you own and operate, deployed with a ready-made Docker Compose bundle. Your agents report to your server; telemetry, events, health metrics, and diagnostic data live in your database and never transit ET Ducky's cloud.

It is built for organizations that need data to stay on their own network, teams with large fleets (the subscription includes unlimited agents at one flat price), and MSPs standardizing on their own hosting.

Local-First is not an air-gap product. The instance needs outbound HTTPS for user sign-in, license renewal, and image updates — a short, fixed egress list documented below. If your primary goal is only controlling AI spend or keeping AI prompts on your own provider account, you don't need Local-First: cloud-hosted customers can bring their own AI key.

The Subscription

How licensing works

Your subscription is embodied in a signed license file (etducky.lic + etducky.lic.sig) downloaded from the Local Deployment page of your etducky.com account. The instance validates the signature at startup and renews the license automatically over HTTPS while your subscription is active. If renewal is interrupted (network outage, expired card), the instance keeps running through a generous grace window and warns administrators in the dashboard well before anything stops. Canceling the subscription stops renewal, but the instance never shuts itself down and never touches your data: past the grace window it drops to collection-only mode — agents keep reporting and telemetry keeps landing in your database, while the dashboard becomes read-only and automations, alerts, AI, and exports pause until the subscription is renewed.

Purchasing, Step by Step

1. Sign in (or create your account) on etducky.com and make sure you belong to the organization that will own the deployment — the tier is purchased for an organization, and only org admins can complete checkout. If you're brand new, create your account first; your organization and workspace are set up automatically during signup.
2. Go to the pricing page, open the Self-Hosted tab, and click Purchase Local-First.
3. Choose billing: monthly ($650/mo, cancel anytime) or annual ($6,630/yr — 15% off).
4. Complete checkout. Payment is handled by Stripe on etducky.com — your future local instance never touches payment data.
5. Provisioning is automatic. Within moments of payment: your signed license is issued, registry access is prepared, a confirmation email arrives with your next steps, and a new Local Deployment page appears in your dashboard. You'll be redirected there after checkout.

Your Local Deployment Page

Everything instance-specific lives on one page of your etducky.com account: sign in and go to Configuration → Local Deployment. You'll use it during setup and any time you need to re-download or rotate credentials.

The renewal secret and pull token are shown once by design — we store only hashes. Losing one is a ten-second fix: regenerate it on this page and update your .env or docker login.

Server Requirements

Resource-sufficiency matters. The API server and the bundled database run on the same Docker host and are sized together. An under-resourced host is the most common cause of slow dashboards and delayed agent data — when in doubt, size up, especially disk.

• OS: Linux x64 with Docker Engine + Compose v2, or Windows Server 2022+ with Docker Desktop (WSL2 backend). The same containers run on both.
• Database: bundled — the compose stack runs PostgreSQL with TimescaleDB alongside the API. No separate database install. (If you have a hard requirement for an external database server, contact support: it must have the TimescaleDB extension available, which excludes most managed Postgres offerings.)
• Disk growth: event and metric history grows with fleet size and retention appetite. Monitor free space; the automatic pre-upgrade backups in ./backups/ also consume disk and are yours to rotate.
• Network: a DNS name your technicians will browse to, and outbound HTTPS to the egress list below. Agents connect inbound to this hostname on your chosen port.

Before You Begin

Have these ready — the installation itself takes well under an hour:

• An active Local-First subscription. Everything instance-specific comes from the Local Deployment page of your etducky.com account: the deployment bundle, your license files, and a registry pull token.
• A Docker host meeting the sizing table above.
• A DNS name (e.g. rmm.yourcompany.internal) pointing at the host.
• A TLS reverse proxy (recommended): nginx, Caddy, Traefik, or IIS ARR. The container serves plain HTTP; terminate TLS in front of it.
• SMTP relay credentials — required for alert and invite email.
• Your AI choice: an Anthropic/OpenAI API key (BYOK, unlimited queries) or a query subscription on your org.

Installation

1. Unpack the bundle from your Local Deployment page into a directory, e.g. /opt/etducky.
2. Create your config: cp .env.template .env and fill in every required value:

   Variable	What it is
   ETDUCKY_IMAGE	Image reference from your Local Deployment page. Pin a version tag for change control, or use stable to follow the latest release.
   ETDUCKY_HOSTNAME	The hostname your users browse to — must match your DNS/proxy exactly.
   HTTP_PORT	Host port the instance serves on (your TLS proxy points here).
   POSTGRES_PASSWORD	Generate once; used only inside the compose network and for backups.
   ETDUCKY_LICENSE_SECRET	The renewal secret from your Local Deployment page (shown once when generated). Authorizes automatic license renewal.
   SMTP_*	Your mail relay for alerts and invites.
   APP_DB_PASSWORD	Optional. Separate password for the least-privilege database role the application runs as. Leave unset to reuse POSTGRES_PASSWORD.

3. Install your license: download etducky.lic and etducky.lic.sig from the Local Deployment page into ./license/.
4. Log in to the registry with the pull token from the same page:
   docker login registry.etducky.com -u <token-name> -p <token>
5. Start the stack: docker compose up -d
6. Watch first boot: docker compose logs -f migrate api. Startup always runs in a fixed order — backup → migrate → api — and on a brand-new install the migrate step builds the full database schema (a minute or two). The API then reports healthy.
7. Register your hostname on the Local Deployment page (Instance hostname section) if you haven't already — sign-in at your instance is blocked until its address is authorized.
8. Sign in: browse to your hostname and sign in with your existing ET Ducky account (see the next section).
9. Enroll your first agent: generate a registration token in the dashboard as usual — installers from your instance are pre-pointed at your hostname.

A failed migration never leaves you stranded: the API deliberately does not start, your data is untouched, and the pre-migration database dump is already in ./backups/.

Signing In & Managing Your Team

Identity stays with your existing ET Ducky accounts — there is no separate local user database to manage, and removing someone from your org locks them out of the local instance too.

• Who can sign in: any member of the org that holds the subscription. Sign in at your instance's URL with email/password, email code, or Google / Microsoft / Slack — two-factor (TOTP) is fully supported.
• Browser requirement: the sign-in page in each technician's browser talks directly to ET Ducky's identity service (clerk.etducky.com), so workstations need outbound HTTPS to it. The instance itself uses the same endpoint to validate session tokens.
• Inviting technicians: org membership is managed from your etducky.com account (not the local instance — membership changes require our identity backend, which never ships to customer infrastructure). Invite a tech there; once they accept, they sign in at your local URL. The local instance syncs the org roster on a short interval, so removals propagate within minutes and the instance tolerates cloud outages of up to 24 hours without any effect on sign-ins.

AI Features: BYOK or Query Subscription

All AI diagnostics (live sessions, multi-agent questions, smart reports, alert enrichment, root-cause analysis) work on Local-First. Choose one of:

• BYOK (recommended): enter your own Anthropic or OpenAI API key under Settings → AI Settings in your local dashboard. The key is stored encrypted in your database, requests go directly from your instance to your provider, and queries are unlimited — you pay your AI provider, not ET Ducky. See BYOK documentation.
• Query subscription: if you'd rather not manage provider keys, add any cloud query subscription to your org. Note the disclosed trade-off: AI query content then transits the ET Ducky gateway. This is off by default and entirely optional.

Upgrades

docker compose pull
docker compose up -d

• Every up re-runs the same backup → migrate → api sequence as install, so a fresh pre-migration database dump lands in ./backups/ before any schema change applies.
• Version-skipping upgrades (N → N+3) are supported — the migration chain is forward-only and self-applying.
• Pin a specific image tag in .env to control exactly when upgrades happen; stable follows our latest release. Automate with cron or a scheduled task if desired.

Backup & Restore

• Automatic: a gzip'd pg_dump is written to ./backups/ before every migration.
• Manual, anytime: docker compose exec db pg_dump -U etducky etducky | gzip > manual-backup.sql.gz
• Also back up: the storage volume (agent-uploaded files) and your ./license/ directory.

Restore (destructive — replaces current data):

docker compose down
docker volume rm <project>_pgdata
docker compose up -d db
gunzip -c backups/<file>.sql.gz | docker compose exec -T db psql -U etducky -d etducky
docker compose up -d

Network Egress (Complete List)

Customer telemetry never leaves your infrastructure. The only exception is the optional cloud query subscription described above — disclosed, and off by default.

TLS

The container serves plain HTTP on HTTP_PORT. Put your reverse proxy in front of it and terminate TLS there — nginx, Caddy, Traefik, or IIS ARR all work. Proxy / and WebSockets to localhost:<HTTP_PORT> (live sessions and remote desktop require WebSocket pass-through).

Troubleshooting

• migrate exited non-zero: the API deliberately did not start. Check docker compose logs migrate. Your data is untouched and the pre-migration backup is in ./backups/.
• Startup says a license is required or invalid: confirm both etducky.lic and etducky.lic.sig are in ./license/ next to docker-compose.yml, exactly as downloaded (they are signature-checked byte-for-byte — don't edit, re-encode, or let a transfer tool alter them). Re-download both from the Local Deployment page if in doubt.
• Login works but pages are empty: check that AllowedHosts / ETDUCKY_HOSTNAME matches the hostname you are browsing to.
• Sign-in button unresponsive or sign-in errors: confirm technicians' browsers can reach clerk.etducky.com, and that your instance hostname was registered on your Local Deployment page (this authorizes the origin for sign-in).
• Slow dashboard / lagging agent data: check host CPU, RAM, and disk headroom against the sizing table — under-resourcing is the usual cause.
• Anything else: business-hours support is included; email [email protected]. If you'd like us to drive the whole setup with you, ask about the $2,500 guided setup.