diff --git a/Makefile b/Makefile
index 71e9610..9ad8070 100644
--- a/Makefile
+++ b/Makefile
@@ -1,19 +1,13 @@
 
-all: hivemind hivemind-musl hivemind-lite
+all: hivemind hivemind-lite
 
 hivemind:
 	go build -o build/hivemind ./cmd/hivemind
 
-hivemind-musl:
-	CC=musl-gcc go build \
-	   -ldflags="-linkmode external -extldflags '-static'" \
-	   -o build/hivemind-musl \
-	   ./cmd/hivemind
-
 hivemind-lite:
 	CC=musl-gcc go build \
 	   -ldflags="-linkmode external -extldflags '-static'" \
 	   -o build/hivemind-lite \
 	   ./cmd/hivemind-lite
 
-.phony: all hivemind hivemind-musl hivemind-lite
+.phony: all hivemind hivemind-lite
diff --git a/TODO.md b/TODO.md
deleted file mode 100644
index 27f744a..0000000
--- a/TODO.md
+++ /dev/null
@@ -1,5 +0,0 @@
-- nginx role
-- don't make roles beg to keep them alive, instead wait for a timeout since the last keepalive message and then probe them
-- think about choosing the master for the keepalive message (should be somewhat load-balanced)
-- hivemind lite should not just print `hivemind-lite` lol
-- different transport (maybe something like a custom binary protocol)
diff --git a/cmd/hivemind/main.go b/cmd/hivemind/main.go
index c614986..7496017 100644
--- a/cmd/hivemind/main.go
+++ b/cmd/hivemind/main.go
@@ -7,7 +7,6 @@ import (
 	"os/signal"
 	"path/filepath"
 	"strconv"
-	"strings"
 	"syscall"
 
 	"git.wzray.com/homelab/hivemind/internal/config"
@@ -28,8 +27,8 @@ import (
 )
 
 var (
-	configFile    = "/etc/hivemind/config.toml"
-	registryFile  = "/var/lib/hivemind/registry"
+	configFile   = "/etc/hivemind/config.toml"
+	registryFile = "/var/lib/hivemind/registry"
 )
 
 func levelToZerolog(l config.LogLevel) zerolog.Level {
@@ -65,22 +64,22 @@ func init() {
 }
 
 func main() {
-	configuration, err := config.FromFile(configFile)
+	config, err := config.FromFile(configFile)
 	if err != nil {
 		log.Fatal().Err(err).Msg("unable to read config file")
 	}
 
-	if err := configuration.Validate(); err != nil {
+	if err := config.Validate(); err != nil {
 		log.Fatal().Err(err).Msg("invalid configuration")
 	}
 
-	zerolog.SetGlobalLevel(levelToZerolog(configuration.Node.LogLevel))
+	zerolog.SetGlobalLevel(levelToZerolog(config.Node.LogLevel))
 
 	self := types.NewNode(
-		configuration.Node.Hostname,
-		configuration.Node.Address,
-		configuration.Node.Port,
-		configuration.Roles,
+		config.Node.Hostname,
+		config.Node.Address,
+		config.Node.Port,
+		config.Roles,
 	)
 
 	filestore := registry.NewFileStorage(registryFile)
@@ -89,29 +88,29 @@ func main() {
 
 	state := state.New(registry, self)
 
-	nodeRole := node.New(state, configuration.Node)
+	nodeRole := node.New(state, config.Node)
 
 	var builder middleware.MiddlewareBuilder
 	middlewares := builder.Prepare()
 
 	client.Init(middlewares)
 
-	listenAddr := fmt.Sprintf("%v:%v", configuration.Node.ListenOn, configuration.Node.Port)
+	listenAddr := fmt.Sprintf("%v:%v", config.Node.ListenOn, config.Node.Port)
 	server := server.NewServer(listenAddr, middlewares)
 
 	roles := make([]roles.Role, 0)
 	roles = append(roles, nodeRole)
 
-	for _, role := range configuration.Roles {
+	for _, role := range config.Roles {
 		switch role {
 		case types.MasterRole:
-			role := master.New(state, configuration.Configs.Master)
+			role := master.New(state, config.Configs.Master)
 			roles = append(roles, role)
 		case types.DnsRole:
-			role := dns.New(state, configuration.Configs.Dns)
+			role := dns.New(state, config.Configs.Dns)
 			roles = append(roles, role)
 		case types.HostRole:
-			role := host.New(state, configuration.Configs.Host)
+			role := host.New(state, config.Configs.Host)
 			roles = append(roles, role)
 		}
 	}
@@ -126,12 +125,7 @@ func main() {
 		serverError <- server.Listen()
 	}()
 
-	bootstrapMaster := configuration.Node.BootstrapMaster
-	if !strings.Contains(bootstrapMaster, ":") {
-		bootstrapMaster += fmt.Sprintf(":%d", config.DefaultConfig.Node.Port)
-	}
-
-	if err := nodeRole.Join(bootstrapMaster); err != nil {
+	if err := nodeRole.Join(config.Node.BootstrapMaster); err != nil {
 		log.Warn().Err(err).Msg("unable to join")
 	} else {
 		log.Info().Msg("joined")
diff --git a/internal/config/config.go b/internal/config/config.go
index 2a3a76f..25ee12d 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -40,7 +40,7 @@ func FromFile(filename string) (Config, error) {
 		return Config{}, fmt.Errorf("parse config file: %w", err)
 	}
 
-	config := DefaultConfig
+	config := defaultConfig
 	config.Node.Merge(temp.Node)
 
 	if c := temp.Configs.Master; c != nil {
diff --git a/internal/config/defaults.go b/internal/config/defaults.go
index d0c2a30..c788047 100644
--- a/internal/config/defaults.go
+++ b/internal/config/defaults.go
@@ -1,17 +1,17 @@
 package config
 
-var DefaultConfig = Config{
+var defaultConfig = Config{
 	Node: NodeConfig{
 		ListenOn:          "0.0.0.0",
 		Port:              56714,
-		KeepaliveInterval: 10,
+		KeepaliveInterval: 1,
 		LogLevel:          LogLevelInfo,
 	},
 	Configs: Configs{
 		Master: MasterConfig{
-			ObserverInterval: 120,
-			BackoffSeconds:   1,
-			BackoffCount:     4,
+			ObserverInterval: 10,
+			BackoffSeconds:   2,
+			BackoffCount:     3,
 		},
 	},
 }
diff --git a/internal/roles/host/host.go b/internal/roles/host/host.go
index ca61e2f..2b35181 100644
--- a/internal/roles/host/host.go
+++ b/internal/roles/host/host.go
@@ -93,12 +93,7 @@ func (r *Role) getInternal() (types.HostState, error) {
 }
 
 func (r *Role) getExternal() (types.HostState, error) {
-	return types.HostState{
-		Domains:  r.externalDomains,
-		Address:  r.config.IpAddress,
-		Hostname: r.state.Self.Hostname,
-	}, nil
-
+	return types.HostState{}, nil
 }
 
 func (r *Role) RegisterHandlers(rg types.Registrator) {
diff --git a/internal/roles/master/observer.go b/internal/roles/master/observer.go
index 46153b2..64f69c8 100644
--- a/internal/roles/master/observer.go
+++ b/internal/roles/master/observer.go
@@ -39,7 +39,7 @@ func (o *observer) pollNodes(ctx context.Context, onLeave func(types.Node) error
 
 		delay := time.Duration(o.backoff)
 		alive := false
-		for i := o.backoffCount - 1; i >= 0; i-- {
+		for i := o.backoffCount; i > 0; i-- {
 			_, err := client.Get[any](n.Endpoint, types.PathNodeHealthcheck)
 
 			if err == nil {
diff --git a/internal/roles/node/node.go b/internal/roles/node/node.go
index 5bc113e..762ae4b 100644
--- a/internal/roles/node/node.go
+++ b/internal/roles/node/node.go
@@ -3,7 +3,6 @@ package node
 import (
 	"context"
 	"errors"
-	"fmt"
 	"sync"
 	"time"
 
@@ -15,14 +14,14 @@ import (
 )
 
 type Role struct {
-	state          *state.RuntimeState
+	state *state.RuntimeState
 	keepaliveGroup sync.WaitGroup
-	config         config.NodeConfig
+	config config.NodeConfig
 }
 
 func New(state *state.RuntimeState, config config.NodeConfig) *Role {
 	return &Role{
-		state:  state,
+		state: state,
 		config: config,
 	}
 }
@@ -41,28 +40,25 @@ func (r *Role) Join(bootstrap string) error {
 		return errors.New("no masters configured")
 	}
 
-	var errs []error
 	for m := range masters {
 		logger := log.With().Str("host", m).Logger()
 		logger.Debug().Msg("trying to join via master")
 
 		nodes, err := client.Post[[]types.Node](m, "/master/join", r.state.Self)
 		if err != nil {
-			errs = append(errs, err)
 			logger.Debug().Err(err).Msg("unable to join")
 			continue
 		}
 
 		if err := r.state.Registry.Set(*nodes); err != nil {
 			logger.Debug().Err(err).Msg("unable to set master's nodes")
-			errs = append(errs, err)
 			continue
 		}
 
 		return nil
 	}
 
-	return fmt.Errorf("unable to join with any master: %w", errors.Join(errs...))
+	return errors.New("unable to join")
 }
 
 func (r *Role) Leave() error {
@@ -71,7 +67,7 @@ func (r *Role) Leave() error {
 		return nil
 	}
 
-	var errs []error
+	sent := false
 	for _, m := range masters {
 		logger := log.With().Str("name", m.Hostname).Logger()
 		logger.Debug().Msg("sending leave message")
@@ -79,15 +75,19 @@ func (r *Role) Leave() error {
 		_, err := client.Post[any](m.Endpoint, types.PathMasterLeave, r.state.Self)
 		if err != nil {
 			logger.Debug().Err(err).Msg("unable to send leave message")
-			errs = append(errs, err)
 			continue
 		} else {
+			sent = true
 			logger.Debug().Msg("leave message sent")
-			return nil
+			break
 		}
 	}
 
-	return fmt.Errorf("unable to send leave message to any master: %w", errors.Join(errs...))
+	if !sent {
+		return errors.New("unable to send leave message")
+	}
+
+	return nil
 }
 
 func (r *Role) OnStartup(ctx context.Context) error {
diff --git a/registry.json b/registry.json
new file mode 100644
index 0000000..7f0cda4
--- /dev/null
+++ b/registry.json
@@ -0,0 +1 @@
+{"last_update":1768661288311,"nodes":{"ext.zvray.ru":{"address":"10.160.0.1:56714","name":"ext.zvray.ru","roles":["dns"]},"laptop.spb.wzray.com":{"address":"laptop.spb.wzray.com:56714","name":"laptop.spb.wzray.com","roles":["master","dns","host"]}}}
\ No newline at end of file