diff --git a/ircbot/main.go b/ircbot/main.go
index 5be72ef3..3c08daa5 100644
--- a/ircbot/main.go
+++ b/ircbot/main.go
@@ -201,12 +201,25 @@ func WaitForStatus(ctx context.Context, manager radio.ManagerService, announce r
 	close(noRetry)
 	var retry <-chan time.Time = noRetry
 
+	var lastSong radio.Song
+
 	for {
+		// if we lost connection or are just starting out we retry the connection
+		// only way to exit this loop is by the context being canceled
+		select {
+		case <-ctx.Done():
+			return errors.E(op, ctx.Err())
+		case <-retry:
+		}
+
+		// connect to the status stream
 		stream, err := manager.CurrentStatus(ctx)
 		if err != nil {
-			return errors.E(op, err)
+			zerolog.Ctx(ctx).Error().Err(err).Msg("failed to connect to manager")
+			// if it fails we retry in a short period
+			retry = time.After(time.Second * 5)
+			continue
 		}
-		defer stream.Close()
 
 		for {
 			select {
@@ -218,15 +231,25 @@ func WaitForStatus(ctx context.Context, manager radio.ManagerService, announce r
 
 			status, err := stream.Next()
 			if err != nil {
+				// stream error means we have to get a new stream and should
+				// break out of this inner loop
 				retry = time.After(time.Second * 5)
-				continue
+				break
 			}
 
-			err = announce.AnnounceSong(ctx, status)
-			if err != nil {
-				retry = time.After(time.Second * 5)
-				continue
+			// if song is different from last we announce a Now Starting
+			if !lastSong.EqualTo(status.Song) {
+				err = announce.AnnounceSong(ctx, status)
+				if err != nil {
+					zerolog.Ctx(ctx).Error().Err(err).Msg("failed to announce song")
+				} else {
+					lastSong = status.Song
+				}
 			}
 		}
+
+		// if we leave the inner loop it means our stream broke so we're getting a new one
+		// soon, clean up this current one
+		stream.Close()
 	}
 }
diff --git a/manager/main.go b/manager/main.go
index 5a449b62..70625477 100644
--- a/manager/main.go
+++ b/manager/main.go
@@ -162,8 +162,8 @@ func (m *Manager) loadStreamStatus(ctx context.Context) (*radio.Status, error) {
 			status.Song = *song
 		}
 	}
-	if status.StreamerName != "" {
-		user, err := m.Storage.User(ctx).LookupName(status.StreamerName)
+	if status.User.DJ.ID != 0 {
+		user, err := m.Storage.User(ctx).GetByDJID(status.User.DJ.ID)
 		if err != nil {
 			m.logger.Warn().Err(err).Msg("retrieving database user")
 		} else {
diff --git a/radio.go b/radio.go
index 7dc3fd38..6e313383 100644
--- a/radio.go
+++ b/radio.go
@@ -67,6 +67,18 @@ type Status struct {
 	RequestsEnabled bool
 }
 
+func (s *Status) IsZero() bool {
+	ok := s.User.ID == 0 &&
+		s.Song.ID == 0 &&
+		s.SongInfo == (SongInfo{}) &&
+		s.StreamerName == "" &&
+		s.Listeners == 0 &&
+		s.Thread == "" &&
+		(!s.Song.HasTrack() || s.Song.TrackID == 0)
+
+	return ok
+}
+
 // Copy makes a deep-copy of the status object
 func (s Status) Copy() Status {
 	c := s
diff --git a/radio_test.go b/radio_test.go
index 0d9c74af..ad86ee27 100644
--- a/radio_test.go
+++ b/radio_test.go
@@ -75,6 +75,13 @@ func TestSongRequestable(t *testing.T) {
 	p.TestingRun(t)
 }
 
+func TestStatusIsZero(t *testing.T) {
+	var status Status
+	assert.True(t, status.IsZero())
+	status.Song.DatabaseTrack = &DatabaseTrack{}
+	assert.True(t, status.IsZero())
+}
+
 func TestCalculateCooldown(t *testing.T) {
 	now := time.Now()
 
diff --git a/storage/mariadb/search_test.go b/storage/mariadb/search_test.go
index 152bb294..0e2ac422 100644
--- a/storage/mariadb/search_test.go
+++ b/storage/mariadb/search_test.go
@@ -12,6 +12,7 @@ import (
 	"github.com/davecgh/go-spew/spew"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type splitCase struct {
@@ -85,9 +86,7 @@ func FuzzProcessQuery(f *testing.F) {
 
 	setup := new(MariaDBSetup)
 	s, err := setup.Setup(setupCtx)
-	if err != nil {
-		assert.NoError(f, err)
-	}
+	require.NoError(f, err)
 	defer setup.TearDown(ctx)
 
 	ss := s.(interface {
diff --git a/storage/mariadb/status.go b/storage/mariadb/status.go
index 6d7bc380..503178e5 100644
--- a/storage/mariadb/status.go
+++ b/storage/mariadb/status.go
@@ -16,72 +16,51 @@ type StatusStorage struct {
 func (ss StatusStorage) Store(status radio.Status) error {
 	const op errors.Op = "mariadb/StatusStorage.Store"
 
-	// TODO(wessie): use INSERT INTO ... ON DUPLICATE UPDATE maybe?
-	// we either want to do an UPDATE or an INSERT if our row doesn't exist
-	var queries = []string{`
-		UPDATE
-			streamstatus
-		SET
-			djid=:user.dj.id,
-			np=:song.metadata,
-			listeners=:listeners,
-			bitrate=192000,
-			isafkstream=0,
-			isstreamdesk=0,
-			start_time=UNIX_TIMESTAMP(:songinfo.start),
-			end_time=UNIX_TIMESTAMP(:songinfo.end),
-			trackid=:song.trackid,
-			thread=:thread,
-			requesting=:requestsenabled,
-			djname=:streamername,
-			lastset=NOW()
-		WHERE
-			id=0;
-		`, `
-		INSERT INTO
+	var query = `
+	INSERT INTO
 			streamstatus
-		(
-			id,
-			djid,
-			np,
-			listeners,
-			isafkstream,
-			start_time,
-			end_time,
-			trackid,
-			thread,
-			requesting,
-			djname
-		) VALUES (
-			0,
-			:user.dj.id,
-			:song.metadata,
-			:listeners,
-			0,
-			UNIX_TIMESTAMP(:songinfo.start),
-			UNIX_TIMESTAMP(:songinfo.end),
-			:song.trackid,
-			:thread,
-			:requestsenabled,
-			:streamername
-		);
-	`}
-
-	// now try the UPDATE and if that fails do the same with an INSERT
-	for _, query := range queries {
-		res, err := sqlx.NamedExec(ss.handle, query, status)
-		if err != nil {
-			return errors.E(op, err)
-		}
+			(
+				id,
+				djid,
+				np,
+				listeners,
+				isafkstream,
+				start_time,
+				end_time,
+				trackid,
+				thread,
+				requesting,
+				djname
+			) VALUES (
+				1,
+				:user.dj.id,
+				:song.metadata,
+				:listeners,
+				0,
+				UNIX_TIMESTAMP(:songinfo.start),
+				UNIX_TIMESTAMP(:songinfo.end),
+				:song.trackid,
+				:thread,
+				:requestsenabled,
+				:streamername
+			) ON DUPLICATE KEY UPDATE 
+				djid=:user.dj.id,
+				np=:song.metadata,
+				listeners=:listeners,
+				isafkstream=0,
+				start_time=UNIX_TIMESTAMP(:songinfo.start),
+				end_time=UNIX_TIMESTAMP(:songinfo.end),
+				trackid=:song.trackid,
+				thread=:thread,
+				requesting=:requestsenabled,
+				djname=:streamername,
+				lastset=NOW();
+	`
 
-		// check if we've successfully updated, otherwise we need to do an insert
-		if i, err := res.RowsAffected(); err != nil {
-			return errors.E(op, err)
-		} else if i > 0 { // success
-			return nil
-		}
+	_, err := sqlx.NamedExec(ss.handle, query, status)
+	if err != nil {
+		return errors.E(op, err)
 	}
-
 	return nil
 }
 
@@ -98,12 +77,12 @@ func (ss StatusStorage) Load() (*radio.Status, error) {
 			from_unixtime(end_time) AS 'songinfo.end',
 			trackid AS 'song.trackid',
 			thread,
-			requesting AS requestsenabled,
-			djname AS 'streamername'
+			IF(requesting = 1, 'true', 'false') AS requestsenabled,
+			djname AS streamername
 		FROM
 			streamstatus
 		WHERE
-			id=0
+			id=1
 		LIMIT 1;
 	`
 
diff --git a/storage/test/status.go b/storage/test/status.go
new file mode 100644
index 00000000..841384ee
--- /dev/null
+++ b/storage/test/status.go
@@ -0,0 +1,52 @@
+package storagetest
+
+import (
+	"time"
+
+	radio "github.com/R-a-dio/valkyrie"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func (suite *Suite) TestStatusStore() {
+	t := suite.T()
+	ss := suite.Storage.Status(suite.ctx)
+
+	in := radio.Status{
+		User: radio.User{
+			DJ: radio.DJ{
+				ID: 500,
+			},
+		},
+		Song: radio.Song{
+			Metadata: "testing data",
+			DatabaseTrack: &radio.DatabaseTrack{
+				TrackID: 1500,
+			},
+		},
+		SongInfo: radio.SongInfo{
+			Start: time.Date(2000, time.April, 1, 5, 6, 7, 8, time.UTC),
+			End:   time.Date(2010, time.February, 10, 15, 16, 17, 18, time.UTC),
+		},
+		Listeners:       900,
+		StreamerName:    "test",
+		Thread:          "a cool thread",
+		RequestsEnabled: true,
+	}
+
+	err := ss.Store(in)
+	require.NoError(t, err)
+
+	out, err := ss.Load()
+	require.NoError(t, err)
+	assert.Condition(t, func() (success bool) {
+		return assert.Equal(t, in.User, out.User) &&
+			assert.Equal(t, in.Song, out.Song) &&
+			assert.WithinDuration(t, in.SongInfo.Start, out.SongInfo.Start, 0) &&
+			assert.WithinDuration(t, in.SongInfo.End, out.SongInfo.End, 0) &&
+			assert.Equal(t, in.Listeners, out.Listeners) &&
+			assert.Equal(t, in.StreamerName, out.StreamerName) &&
+			assert.Equal(t, in.Thread, out.Thread) &&
+			assert.Equal(t, in.RequestsEnabled, out.RequestsEnabled)
+	})
+}
diff --git a/templates/default/home.tmpl b/templates/default/home.tmpl
index b3778871..ad5ba788 100644
--- a/templates/default/home.tmpl
+++ b/templates/default/home.tmpl
@@ -30,23 +30,12 @@
                 </div>
                 <div sse-swap="metadata">
                     {{template "nowplaying" .Status}}
-                </div>
-                <div class="columns">
-                    <div class="column is-6">
-                        <p class="has-text-centered">Listeners: <span id="listener-count">{{.Status.Listeners}}</span></p>
-                    </div>
-                    <div class="column is-6">
-                        <p class="has-text-centered"><span id="progress-current" data-start="{{.Status.SongInfo.Start.UnixMilli}}">00:00</span> / <span id="progress-max">00:00<span></p>
-                    </div>
+                
+
                 </div>
             </div>
-            <div class="column is-3">
-                <div id="dj-image" class="md-5">
-                    <figure class="image is-square">
-                        <img src="/api/dj-image/{{.Status.User.DJ.Image}}">
-                    </figure>
-                    <h4 class="title has-text-centered">{{.Status.User.DJ.Name}}</h4>
-                </div>
+            <div class="column is-3" sse-swap="streamer">
+                {{template "streamer" .Status.User}}
             </div>
         </div>
         <div class="columns">
@@ -92,7 +81,15 @@ Home {{printjson .}}
     <p id="metadata" class="title is-2 has-text-centered" style="cursor: pointer;">{{.Song.Metadata}}</p>
     <p class="subtitle is-4 has-text-centered" style="font-size: 14px;">{{if .Song.DatabaseTrack}}{{.Song.Tags}}{{end}}</p>
 </h2>
-<progress id="current-song-progress" class="progress is-large" value="0" max="{{.Song.Length.Seconds}}"></progress>
+<progress id="current-song-progress" class="progress is-large mb-0" value="0" max="{{.Song.Length.Seconds}}"></progress>
+<div class="columns">
+    <div class="column is-6">
+        <p class="has-text-centered">Listeners: <span id="listener-count">{{.Listeners}}</span></p>
+    </div>
+    <div class="column is-6">
+        <p class="has-text-centered"><span id="progress-current" data-start="{{.SongInfo.Start.UnixMilli}}">00:00</span> / <span id="progress-max">{{.Song.Length | MediaDuration}}<span></p>
+    </div>
+</div>
 {{end}}
 {{define "lastplayed"}}
 <p class="title is-4 has-text-centered">Last Played</p>
@@ -119,4 +116,16 @@ Home {{printjson .}}
         {{end}}
     </ul>
 </div>
+{{end}}
+{{define "streamer"}}
+<div class="card has-background-white-bis p-4 m-2">
+    <div class="card-image">
+        <figure class="image is-square ml-0 mr-0">
+            <img src="/api/dj-image/{{.DJ.Image}}"/>
+        </figure>
+    </div>
+    <div class="card-content has-text-centered pt-4 pb-0">
+        <div class="title is-4 word-break-ellipsis">{{.DJ.Name}}</div>
+    </div>
+</div>
 {{end}}
\ No newline at end of file
diff --git a/website/api/v1/sse.go b/website/api/v1/sse.go
index fa2b2286..d6380fa8 100644
--- a/website/api/v1/sse.go
+++ b/website/api/v1/sse.go
@@ -26,56 +26,62 @@ func prepareStream[T any](ctx context.Context, fn func(context.Context) (T, erro
 		}
 		zerolog.Ctx(ctx).Error().Err(err).Msg("failed to prepare stream")
 
-		time.Sleep(time.Second * 3)
 		select {
 		case <-ctx.Done():
 			return s, ctx.Err()
-		default:
+		case <-time.After(time.Second * 3):
 		}
 	}
 }
 
-func (a *API) runSSE(ctx context.Context) error {
-	var wg sync.WaitGroup
-
-	wg.Add(1)
-	// prepare our eventstreams from the manager
-	go func() {
-		defer wg.Done()
-		a.runSongUpdates(ctx)
-	}()
-
-	wg.Wait()
-	return nil
+func (a *API) runSSE(ctx context.Context) {
+	for {
+		err := a.runStatusUpdates(ctx)
+		if errors.IsE(err, context.Canceled) {
+			return
+		}
+	}
 }
 
-func (a *API) runSongUpdates(ctx context.Context) error {
+func (a *API) runStatusUpdates(ctx context.Context) error {
 	const op errors.Op = "website/api/v1/API.runSongUpdates"
 
-	log := zerolog.Ctx(ctx).With().Str("stream", "song").Logger()
+	log := zerolog.Ctx(ctx).With().Str("sse", "song").Logger()
 
-	song_stream, err := prepareStream(ctx, a.manager.CurrentSong)
+	statusStream, err := prepareStream(ctx, a.manager.CurrentStatus)
 	if err != nil {
 		return errors.E(op, err)
 	}
 
+	var previous radio.Status
+
 	for {
-		us, err := song_stream.Next()
+		status, err := statusStream.Next()
 		if err != nil {
 			log.Error().Err(err).Msg("source failure")
 			break
 		}
 
-		if us == nil {
-			log.Debug().Msg("nil value")
+		if status.IsZero() {
+			log.Debug().Msg("zero value")
 			continue
 		}
 
-		log.Debug().Any("value", us).Msg("sending")
-		a.sse.SendNowPlaying(us)
-		// TODO: add a timeout scenario
-		go a.sendQueue(ctx)
-		go a.sendLastPlayed(ctx)
+		// we send to the now playing sse stream and separately to
+		// a streamer sse stream
+		if !status.Song.EqualTo(previous.Song) {
+			log.Debug().Str("event", EventMetadata).Any("value", status).Msg("sending")
+			a.sse.SendNowPlaying(status)
+			go a.sendQueue(ctx)
+			go a.sendLastPlayed(ctx)
+		}
+
+		if status.User.ID != previous.User.ID {
+			log.Debug().Str("event", EventStreamer).Any("value", status.User).Msg("sending")
+			a.sse.SendStreamer(status.User)
+		}
+
+		previous = status
 	}
 
 	return nil
@@ -84,7 +90,7 @@ func (a *API) runSongUpdates(ctx context.Context) error {
 func (a *API) sendQueue(ctx context.Context) {
 	q, err := a.streamer.Queue(ctx)
 	if err != nil {
-		zerolog.Ctx(ctx).Error().Err(err).Str("stream", "queue").Msg("")
+		zerolog.Ctx(ctx).Error().Err(err).Str("sse", "queue").Msg("")
 		return
 	}
 
@@ -94,7 +100,7 @@ func (a *API) sendQueue(ctx context.Context) {
 func (a *API) sendLastPlayed(ctx context.Context) {
 	lp, err := a.song.Song(ctx).LastPlayed(0, 5)
 	if err != nil {
-		zerolog.Ctx(ctx).Error().Err(err).Str("stream", "lastplayed").Msg("")
+		zerolog.Ctx(ctx).Error().Err(err).Str("sse", "lastplayed").Msg("")
 		return
 	}
 
@@ -177,6 +183,7 @@ func (s *Stream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	for _, m := range init {
 		log.Debug().Bytes("value", m[theme]).Msg("send")
 		if _, err := w.Write(m[theme]); err != nil {
+			log.Error().Err(err).Msg("sse client write error")
 			return
 		}
 	}
@@ -187,6 +194,7 @@ func (s *Stream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	for m := range ch {
 		log.Debug().Bytes("value", m[theme]).Msg("send")
 		if _, err := w.Write(m[theme]); err != nil {
+			log.Error().Err(err).Msg("sse client write error")
 			return
 		}
 		controller.Flush()
@@ -280,11 +288,12 @@ func (s *Stream) NewMessage(event EventName, data templates.TemplateSelectable)
 	return m
 }
 
-func (s *Stream) SendNowPlaying(data *radio.SongUpdate) {
-	if data == nil {
-		return
-	}
-	s.SendEvent(EventMetadata, s.NewMessage(EventMetadata, NowPlaying(*data)))
+func (s *Stream) SendStreamer(data radio.User) {
+	s.SendEvent(EventStreamer, s.NewMessage(EventStreamer, Streamer(data)))
+}
+
+func (s *Stream) SendNowPlaying(data radio.Status) {
+	s.SendEvent(EventMetadata, s.NewMessage(EventMetadata, NowPlaying(data)))
 }
 
 func (s *Stream) SendLastPlayed(data []radio.Song) {
@@ -305,7 +314,7 @@ type request struct {
 
 type message map[string][]byte
 
-type NowPlaying radio.SongUpdate
+type NowPlaying radio.Status
 
 func (NowPlaying) TemplateName() string {
 	return "nowplaying"
@@ -334,3 +343,13 @@ func (Queue) TemplateName() string {
 func (Queue) TemplateBundle() string {
 	return "home"
 }
+
+type Streamer radio.User
+
+func (Streamer) TemplateName() string {
+	return "streamer"
+}
+
+func (Streamer) TemplateBundle() string {
+	return "home"
+}