diff --git a/internal/control/cli/controller.go b/internal/control/cli/controller.go
index 261c8c26..dcc89034 100644
--- a/internal/control/cli/controller.go
+++ b/internal/control/cli/controller.go
@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 
 	"github.com/ja-he/dayplan/internal/control"
@@ -57,6 +58,8 @@ type Controller struct {
 
 	// TODO: try to get rid of this
 	ensureEventsPaneTimestampWithinVisibleScroll func(time.Time)
+
+	log zerolog.Logger
 }
 
 // NewController creates a new Controller.
@@ -66,7 +69,10 @@ func NewController(
 	categoryStyling styling.CategoryStyling,
 	stylesheet styling.Stylesheet,
 ) (*Controller, error) {
-	controller := Controller{}
+	controller := Controller{
+		log: log.With().Str("component", "controller").Logger(),
+	}
+	defer controller.goToDay(date)
 
 	categoryGetter := func(name string) model.Category {
 		cat, ok := categoryStyling.GetKnownCategoriesByName()[name]
@@ -85,7 +91,6 @@ func NewController(
 		var err error
 		dp, err = providers.NewFilesDataProvider(
 			path.Join(envData.BaseDirPath, "days"),
-			controller.data.Categories,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("cannot initialize data provider (%w)", err)
diff --git a/internal/control/cli/summarize.go b/internal/control/cli/summarize.go
index 2ac7957d..a289fb4e 100644
--- a/internal/control/cli/summarize.go
+++ b/internal/control/cli/summarize.go
@@ -2,7 +2,6 @@ package cli
 
 import (
 	"fmt"
-	"log"
 	"os"
 	"path"
 	"strings"
@@ -11,6 +10,7 @@ import (
 	"github.com/ja-he/dayplan/internal/config"
 	"github.com/ja-he/dayplan/internal/control"
 	"github.com/ja-he/dayplan/internal/model"
+	"github.com/ja-he/dayplan/internal/storage"
 	"github.com/ja-he/dayplan/internal/storage/providers"
 	"github.com/ja-he/dayplan/internal/styling"
 )
@@ -18,8 +18,8 @@ import (
 // Flags for the `summarize` command line command, for `go-flags` to parse
 // command line args into.
 type SummarizeCommand struct {
-	FromDay string `short:"f" long:"from" description:"the day from which to start summarizing" value-name:"<yyyy-mm-dd>" required:"true"`
-	TilDay  string `short:"t" long:"til" description:"the day til which to summarize (inclusive)" value-name:"<yyyy-mm-dd>" required:"true"`
+	From time.Time `short:"f" long:"from" description:"the timestamp from which to start summarizing" value-name:"<TIME>" required:"true"`
+	Til  time.Time `short:"t" long:"til" description:"the timestamp until which to summarize" value-name:"<TIME>" required:"true"`
 
 	HumanReadable        bool   `long:"human-readable" description:"format times as hours and minutes"`
 	CategoryFilterString string `long:"category-filter" description:"a filter for categories; any named categories included; all included if omitted" value-name:"<cat1>,<cat2>,..."`
@@ -73,14 +73,8 @@ func (command *SummarizeCommand) Execute(args []string) error {
 		styledCategories.Add(cat, style)
 	}
 
-	startDate, err := model.FromString(Opts.SummarizeCommand.FromDay)
-	if err != nil {
-		log.Fatalf("from date '%s' invalid", Opts.SummarizeCommand.FromDay)
-	}
-	currentDate := startDate
-	finalDate, err := model.FromString(Opts.SummarizeCommand.TilDay)
-	if err != nil {
-		log.Fatalf("til date '%s' invalid", Opts.SummarizeCommand.TilDay)
+	if command.Til.Before(command.From) {
+		return fmt.Errorf("from-time must be before til-time")
 	}
 
 	filterCategories := len(Opts.SummarizeCommand.CategoryFilterString) > 0
@@ -92,44 +86,43 @@ func (command *SummarizeCommand) Execute(args []string) error {
 	}
 
 	// TODO: can probably make this mostly async?
-	days := make([]model.EventList, 0)
-	for currentDate != finalDate.Next() {
-		fh := providers.NewFileHandler(path.Join(envData.BaseDirPath, "days"), currentDate)
-		categories := make([]model.Category, 0)
-		for _, cat := range styledCategories.GetAll() {
-			categories = append(categories, cat.Cat)
-		}
-		days = append(days, *fh.Read(categories))
-
-		currentDate = currentDate.Next()
+	var dataProvider storage.DataProvider
+	dataProvider, err = providers.NewFilesDataProvider(path.Join(envData.BaseDirPath, "days"))
+	if err != nil {
+		return fmt.Errorf("can't create file data provider (%w)", err)
 	}
 
-	categoryIncluded := func(cat model.Category) bool {
-		_, ok := includeCategoriesByName[cat.Name]
+	categoryIncluded := func(categoryName string) bool {
+		_, ok := includeCategoriesByName[categoryName]
 		return ok
 	}
 
-	totalSummary := make(map[model.Category]time.Duration)
-	for _, day := range days {
-		daySummary := day.SumUpByCategory()
-		for category, duration := range daySummary {
-			totalSummary[category] += duration
-		}
-	}
+	totalSummary := dataProvider.SumUpTimespanByCategory(command.From, command.Til)
 
 	if Opts.SummarizeCommand.Verbose {
 		fmt.Println("dayplan time summary:")
 
-		fmt.Println("from:            ", Opts.SummarizeCommand.FromDay)
-		fmt.Println("til:             ", Opts.SummarizeCommand.TilDay)
-		fmt.Println("category filter: ", Opts.SummarizeCommand.CategoryFilterString)
+		fmt.Println("from:            ", command.From)
+		fmt.Println("til:             ", command.Til)
+		fmt.Println("category filter: ", command.CategoryFilterString)
 
-		fmt.Println("read", len(days), "days")
 		fmt.Println("total summary:")
 	}
 
-	for category, duration := range totalSummary {
-		if filterCategories && !categoryIncluded(category) {
+	categoriesByName := styledCategories.GetKnownCategoriesByName()
+	for categoryName, duration := range totalSummary {
+		category, ok := categoriesByName[categoryName]
+		if !ok {
+			fmt.Fprint(os.Stderr, "warning: category '", categoryName, "' not found in config\n")
+			category = &model.Category{
+				Name:       categoryName,
+				Priority:   0,
+				Goal:       nil,
+				Deprecated: false,
+			}
+		}
+
+		if filterCategories && !categoryIncluded(categoryName) {
 			continue
 		}
 
@@ -142,7 +135,7 @@ func (command *SummarizeCommand) Execute(args []string) error {
 
 		var goalStr string = ""
 		if category.Goal != nil {
-			goal := model.GoalForRange(category.Goal, startDate, finalDate)
+			goal := model.GoalForRange(category.Goal, command.From, command.Til)
 			actual := time.Duration(duration) * time.Minute
 			deficit := goal - actual
 			deficitStr := fmt.Sprint(deficit - (deficit % time.Minute))
diff --git a/internal/control/cli/timesheet.go b/internal/control/cli/timesheet.go
index 1b1d6431..2713312c 100644
--- a/internal/control/cli/timesheet.go
+++ b/internal/control/cli/timesheet.go
@@ -2,9 +2,7 @@ package cli
 
 import (
 	"fmt"
-	"log"
 	"os"
-	"path"
 	"regexp"
 	"strings"
 	"time"
@@ -12,9 +10,10 @@ import (
 	"github.com/ja-he/dayplan/internal/config"
 	"github.com/ja-he/dayplan/internal/control"
 	"github.com/ja-he/dayplan/internal/model"
-	"github.com/ja-he/dayplan/internal/storage/providers"
+	"github.com/ja-he/dayplan/internal/storage"
 	"github.com/ja-he/dayplan/internal/styling"
 	"github.com/ja-he/dayplan/internal/util"
+	"github.com/rs/zerolog/log"
 )
 
 // TimesheetCommand is the command `timesheet`, which produces a timesheet for
@@ -91,12 +90,12 @@ func (command *TimesheetCommand) Execute(args []string) error {
 
 	startDate, err := model.FromString(command.FromDay)
 	if err != nil {
-		log.Fatalf("from date '%s' invalid", command.FromDay)
+		log.Fatal().Msgf("from date '%s' invalid", command.FromDay)
 	}
 	currentDate := startDate
 	finalDate, err := model.FromString(command.TilDay)
 	if err != nil {
-		log.Fatalf("til date '%s' invalid", command.TilDay)
+		log.Fatal().Msgf("til date '%s' invalid", command.TilDay)
 	}
 
 	type dateAndDay struct {
@@ -104,14 +103,19 @@ func (command *TimesheetCommand) Execute(args []string) error {
 		model.EventList
 	}
 
+	var dataProvider storage.DataProvider
+	log.Fatal().Msg("TODO: initialize data provider")
+
 	data := make([]dateAndDay, 0)
 	for currentDate != finalDate.Next() {
-		fh := providers.NewFileHandler(path.Join(envData.BaseDirPath+"days"), currentDate)
-		categories := make([]model.Category, 0)
-		for _, cat := range styledCategories.GetAll() {
-			categories = append(categories, cat.Cat)
+		events, err := dataProvider.GetEventsCoveringTimerange(currentDate.ToGotime(), currentDate.ToGotime().Add(24*time.Hour))
+		if err != nil {
+			return fmt.Errorf("error while getting events for %s (%w)", currentDate.String(), err)
 		}
-		data = append(data, dateAndDay{currentDate, *fh.Read(categories)})
+		data = append(data, dateAndDay{
+			currentDate,
+			model.EventList{Events: events},
+		})
 
 		currentDate = currentDate.Next()
 	}
diff --git a/internal/model/event.go b/internal/model/event.go
index 4795544a..75ca44f8 100644
--- a/internal/model/event.go
+++ b/internal/model/event.go
@@ -7,7 +7,7 @@ import (
 // ...
 type Event struct {
 	Name  string    `dpedit:"name"`
-	Cat   Category  `dpedit:"category"`
+	Cat   Category  `dpedit:"category"` // TODO: change to just category name
 	Start time.Time `dpedit:",ignore"`
 	End   time.Time `dpedit:",ignore"`
 }
diff --git a/internal/model/goal.go b/internal/model/goal.go
index 6aabbb07..d8bcced5 100644
--- a/internal/model/goal.go
+++ b/internal/model/goal.go
@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/ja-he/dayplan/internal/config"
+	"github.com/rs/zerolog/log"
 )
 
 // Goal defines a time goal.
@@ -169,14 +170,7 @@ func NewWorkweekGoalFromConfig(cfg config.WorkweekGoal) (*WorkweekGoal, error) {
 
 // GoalForRange is a helper to sum up the duration for the given range expected
 // by the given Goal.
-func GoalForRange(goal Goal, startDate, endDate Date) time.Duration {
-	sum := time.Duration(0)
-
-	currentDate := startDate
-	for currentDate != endDate.Next() {
-		sum += goal.Requires(currentDate)
-		currentDate = currentDate.Next()
-	}
-
-	return sum
+func GoalForRange(goal Goal, start, end time.Time) time.Duration {
+	log.Fatal().Msgf("TODO: GoalForRange not implemented")
+	return 0
 }
diff --git a/internal/storage/provider.go b/internal/storage/provider.go
index ae0e6d60..77e0315b 100644
--- a/internal/storage/provider.go
+++ b/internal/storage/provider.go
@@ -44,6 +44,8 @@ type DataProvider interface {
 	SetEventCategory(EventIdentifier, model.Category) error
 	SetEventAllData(EventIdentifier, model.Event) error
 
+	SumUpTimespanByCategory(start time.Time, end time.Time) map[string]time.Duration
+
 	// need something here for mutability, e.g. constructing an editor...
 
 	CommitState() error
diff --git a/internal/storage/providers/files_provider.go b/internal/storage/providers/files_provider.go
index 579f79eb..116f11e7 100644
--- a/internal/storage/providers/files_provider.go
+++ b/internal/storage/providers/files_provider.go
@@ -1,14 +1,11 @@
 package providers
 
 import (
-	"bufio"
 	"fmt"
-	"os"
-	"path"
-	"strings"
 	"sync"
 	"time"
 
+	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 
 	"github.com/ja-he/dayplan/internal/model"
@@ -22,44 +19,52 @@ type FilesDataProvider struct {
 	BasePath string
 
 	fhMutex      sync.RWMutex
-	FileHandlers map[model.Date]*FileHandler
+	FileHandlers map[model.Date]*fileHandler
 
-	categories []model.Category
+	log zerolog.Logger
 }
 
 // NewFilesDataProvider ...
 func NewFilesDataProvider(
 	basePath string,
-	categories []model.Category,
 ) (*FilesDataProvider, error) {
 
 	result := &FilesDataProvider{
 		BasePath:     basePath,
 		fhMutex:      sync.RWMutex{},
-		FileHandlers: make(map[model.Date]*FileHandler),
-		categories:   categories,
+		FileHandlers: make(map[model.Date]*fileHandler),
+		log:          log.With().Str("component", "files-data-provider").Logger(),
 	}
 
 	return result, nil
 }
 
 // TODO: doc getFileHandler
-func (p *FilesDataProvider) getFileHandler(date model.Date) (*FileHandler, error) {
+func (p *FilesDataProvider) getFileHandler(date model.Date) (*fileHandler, error) {
 
 	// check if already loaded
 	{
 		p.fhMutex.RLock()
 		if fh, ok := p.FileHandlers[date]; ok {
+			p.fhMutex.RUnlock()
+			p.log.Trace().Msgf("found already loaded file handler for '%s'", date.String())
 			return fh, nil
 		}
 		p.fhMutex.RUnlock()
 	}
 
+	p.log.Trace().Msgf("file handler for '%s' not yet loaded, loading...", date.String())
+	defer p.log.Trace().Msgf("loaded file handler for '%s'", date.String())
+
 	// add the new handler
 	p.fhMutex.Lock()
-	fh := NewFileHandler(p.BasePath, date)
+	defer p.fhMutex.Unlock()
+	fh, err := newFileHandlerWithDataReadFromDisk(p.BasePath, date)
+	if err != nil {
+		return nil, fmt.Errorf("could not load file handler for '%s' (%w)", date.String(), err)
+	}
 	p.FileHandlers[date] = fh
-	p.fhMutex.Unlock()
+	p.log.Trace().Msgf("file handler for '%s' added to cache", date.String())
 
 	return fh, nil
 }
@@ -81,56 +86,69 @@ func (p *FilesDataProvider) AddEvent(e model.Event) error {
 
 // TODO: doc RemoveEvent
 func (p *FilesDataProvider) RemoveEvent(storage.EventIdentifier) error {
-	panic("TODO IMPL(RemoveEvent)")
+	p.log.Fatal().Msg("TODO IMPL(RemoveEvent)")
+	return nil
 }
 
 // TODO: doc RemoveEvents
 func (p *FilesDataProvider) RemoveEvents([]storage.EventIdentifier) error {
-	panic("TODO IMPL(RemoveEvents)")
+	p.log.Fatal().Msg("TODO IMPL(RemoveEvents)")
+	return nil
 }
 
 // TODO: doc GetEventAfter
 func (p *FilesDataProvider) GetEventAfter(time.Time) (*model.Event, error) {
-	panic("TODO IMPL(GetEventAfter)")
+	p.log.Fatal().Msg("TODO IMPL(GetEventAfter)")
+	return nil, nil
 }
 
 // TODO: doc GetEventBefore
 func (p *FilesDataProvider) GetEventBefore(time.Time) (*model.Event, error) {
-	panic("TODO IMPL(GetEventBefore)")
+	p.log.Fatal().Msg("TODO IMPL(GetEventBefore)")
+	return nil, nil
 }
 
 // TODO: doc GetPrecedingEvent
 func (p *FilesDataProvider) GetPrecedingEvent(storage.EventIdentifier, time.Time) (*model.Event, error) {
-	panic("TODO IMPL(GetPrecedingEvent)")
+	p.log.Fatal().Msg("TODO IMPL(GetPrecedingEvent)")
+	return nil, nil
 }
 
 // TODO: doc GetFollowingEvent
 func (p *FilesDataProvider) GetFollowingEvent(storage.EventIdentifier, time.Time) (*model.Event, error) {
-	panic("TODO IMPL(GetFollowingEvent)")
+	p.log.Fatal().Msg("TODO IMPL(GetFollowingEvent)")
+	return nil, nil
 }
 
 // TODO: doc GetEventsCoveringTimerange
 func (p *FilesDataProvider) GetEventsCoveringTimerange(start, end time.Time) ([]*model.Event, error) {
-	log.Debug().Msgf("getting events covering timerange %s to %s", start.String(), end.String())
+	p.log.Debug().Msgf("getting events covering timerange %s to %s", start.String(), end.String())
 	defer log.Debug().Msgf("done getting events covering timerange %s to %s", start.String(), end.String())
 
 	if end.Before(start) {
 		return nil, fmt.Errorf("end time is before start time")
 	}
+	if start == end {
+		return nil, fmt.Errorf("empty time range requested (start is end)")
+	}
 
-	fhs, err := func() ([]*FileHandler, error) {
-		p.fhMutex.RLock()
-		defer p.fhMutex.RUnlock()
+	fhs, err := func() ([]*fileHandler, error) {
 
-		var result []*FileHandler
+		var result []*fileHandler
 		currentDate := model.DateFromGotime(start)
 		endDate := model.DateFromGotime(end)
+		if end.Hour() == 0 && end.Minute() == 0 && end.Second() == 0 {
+			endDate = endDate.Prev()
+		}
+		p.log.Debug().Msgf("getting file handlers for dates %s to %s", currentDate.String(), endDate.String())
+
 		for !currentDate.IsAfter(endDate) {
 			fh, err := p.getFileHandler(currentDate)
 			if err != nil {
 				return nil, fmt.Errorf("error getting file handler for date %s (%w)", currentDate.String(), err)
 			}
 			result = append(result, fh)
+			currentDate = currentDate.Next()
 		}
 		return result, nil
 	}()
@@ -139,11 +157,11 @@ func (p *FilesDataProvider) GetEventsCoveringTimerange(start, end time.Time) ([]
 	}
 
 	if len(fhs) == 0 {
-		log.Warn().Msgf("somehow, found no file handlers for timerange %s to %s", start.String(), end.String())
+		p.log.Warn().Msgf("somehow, found no file handlers for timerange %s to %s", start.String(), end.String())
 		return nil, nil
 	}
 
-	log.Debug().Msgf("found %d file handlers for timerange %s to %s", len(fhs), start.String(), end.String())
+	p.log.Debug().Msgf("found %d file handlers for timerange %s to %s", len(fhs), start.String(), end.String())
 
 	// NOTE:
 	//   Yes, there is probably a small bit of efficiency to be gained here by
@@ -166,179 +184,94 @@ func (p *FilesDataProvider) GetEventsCoveringTimerange(start, end time.Time) ([]
 
 // TODO: doc SplitEvent
 func (p *FilesDataProvider) SplitEvent(storage.EventIdentifier, time.Time) error {
-	panic("TODO IMPL(SplitEvent)")
+	p.log.Fatal().Msg("TODO IMPL(SplitEvent)")
+	return nil
 }
 
 // TODO: doc SetEventStart
 func (p *FilesDataProvider) SetEventStart(storage.EventIdentifier, time.Time) error {
-	panic("TODO IMPL(SetEventStart)")
+	p.log.Fatal().Msg("TODO IMPL(SetEventStart)")
+	return nil
 }
 
 // TODO: doc SetEventEnd
 func (p *FilesDataProvider) SetEventEnd(storage.EventIdentifier, time.Time) error {
-	panic("TODO IMPL(SetEventEnd)")
+	p.log.Fatal().Msg("TODO IMPL(SetEventEnd)")
+	return nil
 }
 
 // TODO: doc SetEventTimes
 func (p *FilesDataProvider) SetEventTimes(storage.EventIdentifier, time.Time, time.Time) error {
-	panic("TODO IMPL(SetEventTimes)")
+	p.log.Fatal().Msg("TODO IMPL(SetEventTimes)")
+	return nil
 }
 
 // TODO: doc OffsetEventStart
 func (p *FilesDataProvider) OffsetEventStart(storage.EventIdentifier, time.Duration) error {
-	panic("TODO IMPL(OffsetEventStart)")
+	p.log.Fatal().Msg("TODO IMPL(OffsetEventStart)")
+	return nil
 }
 
 // TODO: doc OffsetEventEnd
 func (p *FilesDataProvider) OffsetEventEnd(storage.EventIdentifier, time.Duration) error {
-	panic("TODO IMPL(OffsetEventEnd)")
+	p.log.Fatal().Msg("TODO IMPL(OffsetEventEnd)")
+	return nil
 }
 
 // TODO: doc OffsetEventTimes
 func (p *FilesDataProvider) OffsetEventTimes(storage.EventIdentifier, time.Duration) error {
-	panic("TODO IMPL(OffsetEventTimes)")
+	p.log.Fatal().Msg("TODO IMPL(OffsetEventTimes)")
+	return nil
 }
 
 // TODO: doc SnapEventStart
 func (p *FilesDataProvider) SnapEventStart(storage.EventIdentifier, time.Duration) error {
-	panic("TODO IMPL(SnapEventStart)")
+	p.log.Fatal().Msg("TODO IMPL(SnapEventStart)")
+	return nil
 }
 
 // TODO: doc SnapEventEnd
 func (p *FilesDataProvider) SnapEventEnd(storage.EventIdentifier, time.Duration) error {
-	panic("TODO IMPL(SnapEventEnd)")
+	p.log.Fatal().Msg("TODO IMPL(SnapEventEnd)")
+	return nil
 }
 
 // TODO: doc SnapEventTimes
 func (p *FilesDataProvider) SnapEventTimes(storage.EventIdentifier, time.Duration) error {
-	panic("TODO IMPL(SnapEventTimes)")
+	p.log.Fatal().Msg("TODO IMPL(SnapEventTimes)")
+	return nil
 }
 
 // TODO: doc SetEventTitle
 func (p *FilesDataProvider) SetEventTitle(storage.EventIdentifier, string) error {
-	panic("TODO IMPL(SetEventTitle)")
+	p.log.Fatal().Msg("TODO IMPL(SetEventTitle)")
+	return nil
 }
 
 // TODO: doc SetEventCategory
 func (p *FilesDataProvider) SetEventCategory(storage.EventIdentifier, model.Category) error {
-	panic("TODO IMPL(SetEventCategory)")
+	p.log.Fatal().Msg("TODO IMPL(SetEventCategory)")
+	return nil
 }
 
 // TODO: doc SetEventAllData
 func (p *FilesDataProvider) SetEventAllData(storage.EventIdentifier, model.Event) error {
-	panic("TODO IMPL(SetEventAllData)")
+	p.log.Fatal().Msg("TODO IMPL(SetEventAllData)")
+	return nil
 }
 
 // TODO: doc CommitState
-func (p *FilesDataProvider) CommitState() error { panic("TODO IMPL(CommitState)") }
-
-// FileHandler ...
-type FileHandler struct {
-	mutex sync.Mutex
-
-	basePath string
-	date     model.Date
-
-	data model.EventList
-}
-
-// NewFileHandler ...
-func NewFileHandler(basePath string, date model.Date) *FileHandler {
-	f := FileHandler{basePath: basePath, date: date}
-	return &f
-}
-
-func (h *FileHandler) Write() error {
-	h.mutex.Lock()
-	filename := h.Filename()
-	f, err := os.OpenFile(filename, os.O_TRUNC|os.O_WRONLY|os.O_CREATE, 0644)
-	if err != nil {
-		return fmt.Errorf("could not open file '%s' (%w)", filename, err)
-	}
-
-	writer := bufio.NewWriter(f)
-	// TODO: don't ignore the errors, obviously
-	for _, e := range h.data.Events {
-		_, _ = writer.WriteString(e.String() + "\n")
-	}
-	writer.Flush()
-	f.Close()
-	h.mutex.Unlock()
-
+func (p *FilesDataProvider) CommitState() error {
+	p.log.Fatal().Msg("TODO IMPL(CommitState)")
 	return nil
 }
 
-// Filename ...
-func (h *FileHandler) Filename() string {
-	return path.Join(h.basePath, h.date.String())
-}
-
-// AddEvent ...
-func (h *FileHandler) AddEvent(e *model.Event) error {
-	h.mutex.Lock()
-	defer h.mutex.Unlock()
-
-	err := h.data.AddEvent(e)
-	if err != nil {
-		return fmt.Errorf("error adding event to file handler (%w)", err)
-	}
+// TODO: doc SumUpTimespanByCategory
+func (p *FilesDataProvider) SumUpTimespanByCategory(start time.Time, end time.Time) map[string]time.Duration {
+	p.log.Fatal().Msg("TODO IMPL(SumUpTimespanByCategory)")
 	return nil
 }
 
-// Read ...
-func (h *FileHandler) Read(knownCategories []model.Category) *model.EventList {
-	l := model.EventList{
-		Events: make([]*model.Event, 0),
-	}
-
-	h.mutex.Lock()
-	f, err := os.Open(h.Filename())
-	fileExists := (err == nil)
-	if fileExists {
-		scanner := bufio.NewScanner(f)
-		for scanner.Scan() {
-			s := scanner.Text()
-			l.AddEvent(newEventFromDaywiseFileLine(h.date, s, knownCategories))
-		}
-		f.Close()
-	}
-	h.mutex.Unlock()
-
-	return &l
-}
-
-func newEventFromDaywiseFileLine(date model.Date, line string, knownCategories []model.Category) *model.Event {
-	var e model.Event
-
-	args := strings.SplitN(line, "|", 4)
-	startString := args[0]
-	endString := args[1]
-	catString := args[2]
-	nameString := args[3]
-
-	startTime := *model.NewTimestamp(startString)
-	endTime := *model.NewTimestamp(endString)
-
-	e.Start = model.DateAndTimestampToGotime(date, startTime)
-	e.End = model.DateAndTimestampToGotime(date, endTime)
-
-	var maybeCategory *model.Category
-	for i := range knownCategories {
-		if knownCategories[i].Name == catString {
-			maybeCategory = &knownCategories[i]
-		}
-	}
-
-	e.Name = nameString
-	if maybeCategory != nil {
-		e.Cat = *maybeCategory
-	} else {
-		e.Cat.Name = catString
-	}
-
-	return &e
-}
-
 func eventStartsAndEndsOnSameDate(e *model.Event) bool {
 	return timesOnSameDate(e.Start, e.End)
 }
diff --git a/internal/storage/providers/files_provider_file_handler.go b/internal/storage/providers/files_provider_file_handler.go
new file mode 100644
index 00000000..ea2fc2d6
--- /dev/null
+++ b/internal/storage/providers/files_provider_file_handler.go
@@ -0,0 +1,117 @@
+package providers
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"strings"
+	"sync"
+
+	"github.com/ja-he/dayplan/internal/model"
+)
+
+type fileHandler struct {
+	mutex sync.Mutex
+
+	basePath string
+	date     model.Date
+
+	data model.EventList
+}
+
+func newFileHandlerWithDataReadFromDisk(basePath string, date model.Date) (*fileHandler, error) {
+	f := fileHandler{basePath: basePath, date: date}
+	err := f.readFromDisk()
+	if err != nil {
+		return nil, fmt.Errorf("could not read file from disk (%w)", err)
+	}
+	return &f, nil
+}
+
+func (h *fileHandler) Write() error {
+	h.mutex.Lock()
+	filename := h.Filename()
+	f, err := os.OpenFile(filename, os.O_TRUNC|os.O_WRONLY|os.O_CREATE, 0644)
+	if err != nil {
+		return fmt.Errorf("could not open file '%s' (%w)", filename, err)
+	}
+
+	writer := bufio.NewWriter(f)
+	// TODO: don't ignore the errors, obviously
+	for _, e := range h.data.Events {
+		_, _ = writer.WriteString(e.String() + "\n")
+	}
+	writer.Flush()
+	f.Close()
+	h.mutex.Unlock()
+
+	return nil
+}
+
+// Filename ...
+func (h *fileHandler) Filename() string {
+	return path.Join(h.basePath, h.date.String())
+}
+
+// AddEvent ...
+func (h *fileHandler) AddEvent(e *model.Event) error {
+	h.mutex.Lock()
+	defer h.mutex.Unlock()
+
+	err := h.data.AddEvent(e)
+	if err != nil {
+		return fmt.Errorf("error adding event to file handler (%w)", err)
+	}
+	return nil
+}
+
+// Read ...
+func (h *fileHandler) readFromDisk() error {
+	if len(h.data.Events) != 0 {
+		// warn
+	}
+
+	h.data = model.EventList{
+		Events: make([]*model.Event, 0),
+	}
+
+	f, err := os.Open(h.Filename())
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			// TODO: tell that have loaded as empty
+			return nil
+		}
+		return fmt.Errorf("could not read file '%s' from disk (%w)", h.Filename(), err)
+	}
+
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		s := scanner.Text()
+		h.data.AddEvent(newEventFromDaywiseFileLine(h.date, s))
+	}
+
+	return nil
+}
+
+func newEventFromDaywiseFileLine(date model.Date, line string) *model.Event {
+	var e model.Event
+
+	args := strings.SplitN(line, "|", 4)
+	startString := args[0]
+	endString := args[1]
+	catString := args[2]
+	nameString := args[3]
+
+	startTime := *model.NewTimestamp(startString)
+	endTime := *model.NewTimestamp(endString)
+
+	e.Start = model.DateAndTimestampToGotime(date, startTime)
+	e.End = model.DateAndTimestampToGotime(date, endTime)
+
+	e.Name = nameString
+	e.Cat.Name = catString
+
+	return &e
+}
diff --git a/internal/ui/panes/composite.go b/internal/ui/panes/composite.go
index 3247ed9b..a0b46037 100644
--- a/internal/ui/panes/composite.go
+++ b/internal/ui/panes/composite.go
@@ -4,6 +4,9 @@ import (
 	"fmt"
 	"math"
 
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+
 	"github.com/ja-he/dayplan/internal/input"
 	"github.com/ja-he/dayplan/internal/ui"
 	"github.com/ja-he/dayplan/internal/util"
@@ -18,6 +21,8 @@ type Composite struct {
 	focussables []ui.Pane
 
 	FocussedPane ui.Pane
+
+	log zerolog.Logger
 }
 
 // Draw draws this pane by drawing all its subpanes.
@@ -180,14 +185,17 @@ func NewWrapperPane(
 	focussables []ui.Pane,
 	inputProcessor input.ModalInputProcessor,
 ) *Composite {
+	id := ui.GeneratePaneID()
 	p := &Composite{
 		focussables: focussables,
 		drawables:   drawables,
 		BasePane: ui.BasePane{
 			InputProcessor: inputProcessor,
-			ID:             ui.GeneratePaneID(),
+			ID:             id,
 		},
+		log: log.With().Str("component", fmt.Sprintf("wrapper-pane-%d", id)).Logger(),
 	}
+	defer p.log.Trace().Msgf("constructed new wrapper pane for %d drawables with id '%d'", len(p.drawables), p.Identify())
 	if len(p.focussables) > 0 {
 		p.FocussedPane = p.focussables[0]
 	}
diff --git a/internal/ui/panes/events_pane.go b/internal/ui/panes/events_pane.go
index 23971da8..86a63526 100644
--- a/internal/ui/panes/events_pane.go
+++ b/internal/ui/panes/events_pane.go
@@ -5,6 +5,7 @@ import (
 	"math"
 	"time"
 
+	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 
 	"github.com/ja-he/dayplan/internal/input"
@@ -37,6 +38,8 @@ type EventsPane struct {
 	getCurrentEvent func() *model.Event
 	mouseMode       func() bool
 
+	log zerolog.Logger
+
 	// TODO: get rid of this
 	positions map[*model.Event]util.Rect
 }
@@ -57,6 +60,9 @@ func (p *EventsPane) GetPositionInfo(x, y int) ui.PositionInfo {
 
 // Draw draws this pane.
 func (p *EventsPane) Draw() {
+	p.log.Debug().Msg("drawing...")
+	defer p.log.Debug().Msgf("drawn")
+
 	x, y, w, h := p.Dimensions()
 	style := p.Stylesheet.Normal
 	if p.HasFocus() {
@@ -64,7 +70,9 @@ func (p *EventsPane) Draw() {
 	}
 	p.Renderer.DrawBox(x, y, w, h, style)
 
+	p.log.Trace().Msg("loading day events...")
 	date, day, err := p.dayEvents()
+	p.log.Trace().Msg("loaded.")
 	if err != nil {
 		p.Renderer.DrawBox(x, y, w, h, p.Stylesheet.CategoryFallback.DarkenedBG(20))
 		p.Renderer.DrawText(x, y, w, h, p.Stylesheet.CategoryFallback.DarkenedBG(20).LightenedFG(50).Italicized(), "error (see log)")
@@ -78,13 +86,13 @@ func (p *EventsPane) Draw() {
 	for _, e := range day.Events {
 		start, end := model.FromTime(e.Start), model.FromTime(e.End)
 		if start.Date.IsAfter(date) || end.Date.IsBefore(date) {
-			log.Warn().Stringer("date", date).Stringer("event", e).Msg("got an event where the start date is after the drawn date or end is before drawn date, which should not happen")
+			p.log.Warn().Stringer("date", date).Stringer("event", e).Msg("got an event where the start date is after the drawn date or end is before drawn date, which should not happen")
 			continue
 		}
 
 		style, err := p.styleForCategory(e.Cat)
 		if err != nil {
-			log.Error().Err(err).Str("category-name", e.Cat.Name).Msg("an error occurred getting category style")
+			p.log.Error().Err(err).Str("category-name", e.Cat.Name).Msg("an error occurred getting category style")
 			style = p.Stylesheet.CategoryFallback
 		}
 		if !p.isCurrentDay() {
@@ -172,7 +180,7 @@ func (p *EventsPane) getEventForPos(x, y int) *ui.EventsPanePositionInfo {
 		x < (dimX+dimW) {
 		date, currentDay, err := p.dayEvents()
 		if err != nil {
-			log.Warn().Err(err).Msg("error getting day event for position, presumably this will be handled elsewhere")
+			p.log.Warn().Err(err).Msg("error getting day event for position, presumably this will be handled elsewhere")
 			return nil
 		}
 		for i := len(currentDay.Events) - 1; i >= 0; i-- {
@@ -221,7 +229,7 @@ func (p *EventsPane) computeRects(date model.Date, l *model.EventList, offsetX,
 		// the true start timestamps
 		start, end := model.FromTime(e.Start), model.FromTime(e.End)
 		if start.Date.IsAfter(date) || end.Date.IsBefore(date) {
-			log.Warn().Stringer("date", date).Stringer("event", e).Msg("got an event where the start date is after the drawn date or end is before drawn date, which should not happen")
+			p.log.Warn().Stringer("date", date).Stringer("event", e).Msg("got an event where the start date is after the drawn date or end is before drawn date, which should not happen")
 			continue
 		}
 		var startTS, endTS model.Timestamp
@@ -279,10 +287,11 @@ func NewEventsPane(
 	getCurrentEvent func() *model.Event,
 	mouseMode func() bool,
 ) *EventsPane {
-	return &EventsPane{
+	id := ui.GeneratePaneID()
+	p := &EventsPane{
 		LeafPane: ui.LeafPane{
 			BasePane: ui.BasePane{
-				ID:             ui.GeneratePaneID(),
+				ID:             id,
 				InputProcessor: inputProcessor,
 			},
 			Renderer:   renderer,
@@ -301,5 +310,8 @@ func NewEventsPane(
 		getCurrentEvent:  getCurrentEvent,
 		mouseMode:        mouseMode,
 		positions:        make(map[*model.Event]util.Rect, 0),
+		log:              log.With().Str("component", fmt.Sprintf("events-pane-%d", id)).Logger(),
 	}
+	defer p.log.Info().Msgf("constructed new events pane with id '%d'", p.Identify())
+	return p
 }
diff --git a/internal/ui/panes/root_pane.go b/internal/ui/panes/root_pane.go
index f8e8393e..6c100741 100644
--- a/internal/ui/panes/root_pane.go
+++ b/internal/ui/panes/root_pane.go
@@ -3,6 +3,9 @@ package panes
 import (
 	"sync"
 
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+
 	"github.com/ja-he/dayplan/internal/input"
 	"github.com/ja-he/dayplan/internal/ui"
 	"github.com/ja-he/dayplan/internal/util"
@@ -24,10 +27,10 @@ type RootPane struct {
 	weekViewMainPane  ui.Pane
 	monthViewMainPane ui.Pane
 
-	summary ui.Pane
-	log     ui.Pane
+	summaryPane ui.Pane
+	logPane     ui.Pane
 
-	help ui.Pane
+	helpPane ui.Pane
 
 	subpanesMtx sync.Mutex
 	subpanes    []ui.Pane
@@ -38,6 +41,8 @@ type RootPane struct {
 
 	preDrawStackMtx sync.Mutex
 	preDrawStack    []func()
+
+	log zerolog.Logger
 }
 
 // Dimensions gives the dimensions (x-axis offset, y-axis offset, width,
@@ -68,10 +73,10 @@ func (p *RootPane) getCurrentlyActivePanesInOrder() (active []ui.Pane, inactive
 	// append day, week, or month pane
 	active = append(active, p.focussedViewPane)
 
-	if p.summary.IsVisible() {
-		active = append(active, p.summary)
+	if p.summaryPane.IsVisible() {
+		active = append(active, p.summaryPane)
 	} else {
-		inactive = append(inactive, p.summary)
+		inactive = append(inactive, p.summaryPane)
 	}
 
 	for i := range p.subpanes {
@@ -82,17 +87,17 @@ func (p *RootPane) getCurrentlyActivePanesInOrder() (active []ui.Pane, inactive
 		}
 	}
 
-	if p.log.IsVisible() {
-		active = append(active, p.log)
+	if p.logPane.IsVisible() {
+		active = append(active, p.logPane)
 	} else {
-		inactive = append(inactive, p.log)
+		inactive = append(inactive, p.logPane)
 	}
 
 	// TODO: help should probably be a subpane? for now, always on top.
-	if p.help.IsVisible() {
-		active = append(active, p.help)
+	if p.helpPane.IsVisible() {
+		active = append(active, p.helpPane)
 	} else {
-		inactive = append(inactive, p.help)
+		inactive = append(inactive, p.helpPane)
 	}
 
 	return active, inactive
@@ -118,7 +123,9 @@ func (p *RootPane) Draw() {
 	// FIXME: probably simplify this
 	active, _ := p.getCurrentlyActivePanesInOrder()
 	for _, pane := range active {
+		p.log.Trace().Msgf("drawing %d...", pane.Identify())
 		pane.Draw()
+		p.log.Trace().Msgf("drew %d.", pane.Identify())
 	}
 	// for _, pane := range _ {
 	// 	pane.Undraw()
@@ -234,12 +241,12 @@ func (p *RootPane) FocusNext() {}
 
 func (p *RootPane) focussedPane() ui.Pane {
 	switch {
-	case p.help.IsVisible():
-		return p.help
-	case p.summary.IsVisible():
-		return p.summary
-	case p.log.IsVisible():
-		return p.log
+	case p.helpPane.IsVisible():
+		return p.helpPane
+	case p.summaryPane.IsVisible():
+		return p.summaryPane
+	case p.logPane.IsVisible():
+		return p.logPane
 	default:
 		for i := range p.subpanes {
 			if p.subpanes[i].IsVisible() {
@@ -317,9 +324,9 @@ func NewRootPane(
 	dayViewMainPane *Composite,
 	weekViewMainPane *Composite,
 	monthViewMainPane *Composite,
-	summary ui.Pane,
-	log ui.Pane,
-	help ui.Pane,
+	summaryPane ui.Pane,
+	logPane ui.Pane,
+	helpPane ui.Pane,
 	performanceMetricsOverlay ui.Pane,
 	inputProcessor input.ModalInputProcessor,
 	focussedPane ui.Pane,
@@ -332,20 +339,23 @@ func NewRootPane(
 		dayViewMainPane:           dayViewMainPane,
 		weekViewMainPane:          weekViewMainPane,
 		monthViewMainPane:         monthViewMainPane,
-		summary:                   summary,
-		log:                       log,
-		help:                      help,
+		summaryPane:               summaryPane,
+		logPane:                   logPane,
+		helpPane:                  helpPane,
 		performanceMetricsOverlay: performanceMetricsOverlay,
 		inputProcessor:            inputProcessor,
 		focussedViewPane:          focussedPane,
+		log:                       log.With().Str("component", "root-pane").Logger(),
 	}
+	defer rootPane.log.Trace().Msgf("created root pane with id '%d'", rootPane.Identify())
+
 	dayViewMainPane.SetParent(rootPane)
 	weekViewMainPane.SetParent(rootPane)
 	monthViewMainPane.SetParent(rootPane)
 
-	summary.SetParent(rootPane)
-	help.SetParent(rootPane)
-	log.SetParent(rootPane)
+	summaryPane.SetParent(rootPane)
+	helpPane.SetParent(rootPane)
+	logPane.SetParent(rootPane)
 
 	return rootPane
 }