diff --git a/pkg/uki/install.go b/pkg/uki/install.go
index 001304a..cd103e2 100644
--- a/pkg/uki/install.go
+++ b/pkg/uki/install.go
@@ -31,22 +31,29 @@ func (i *InstallAction) Run() (err error) {
 	cleanup := utils.NewCleanStack()
 	defer func() { err = cleanup.Cleanup(err) }()
 	// Run pre-install stage
-	_ = utils.RunStage(i.cfg, "kairos-uki-install.pre")
-	_ = events.RunHookScript("/usr/bin/kairos-agent.uki.install.pre.hook")
+	if err = utils.RunStage(i.cfg, "kairos-uki-install.pre"); err != nil {
+		i.cfg.Logger.Errorf("running kairos-uki-install.pre stage: %s", err.Error())
+	}
+	if err = events.RunHookScript("/usr/bin/kairos-agent.uki.install.pre.hook"); err != nil {
+		i.cfg.Logger.Errorf("running kairos-uki-install.pre hook script: %s", err.Error())
+	}
 
 	// Deactivate any active volume on target
 	err = e.DeactivateDevices()
 	if err != nil {
+		i.cfg.Logger.Errorf("deactivating devices: %s", err.Error())
 		return err
 	}
 	// Partition device
 	err = e.PartitionAndFormatDevice(i.spec)
 	if err != nil {
+		i.cfg.Logger.Errorf("partitioning and formating devices: %s", err.Error())
 		return err
 	}
 
 	err = e.MountPartitions(i.spec.GetPartitions().PartitionsByMountPoint(false))
 	if err != nil {
+		i.cfg.Logger.Errorf("mounting partitions: %s", err.Error())
 		return err
 	}
 	cleanup.Push(func() error {
@@ -56,6 +63,7 @@ func (i *InstallAction) Run() (err error) {
 	// Before install hook happens after partitioning but before the image OS is applied (this is for compatibility with normal install, so users can reuse their configs)
 	err = Hook(i.cfg, constants.BeforeInstallHook)
 	if err != nil {
+		i.cfg.Logger.Errorf("running before install hook: %s", err.Error())
 		return err
 	}
 
@@ -63,6 +71,7 @@ func (i *InstallAction) Run() (err error) {
 	// Copy cloud-init if any
 	err = e.CopyCloudConfig(i.spec.CloudInit)
 	if err != nil {
+		i.cfg.Logger.Errorf("copying cloud config: %s", err.Error())
 		return err
 	}
 	// Create dir structure
@@ -71,6 +80,7 @@ func (i *InstallAction) Run() (err error) {
 
 	err = fsutils.MkdirAll(i.cfg.Fs, filepath.Join(constants.EfiDir, "EFI", "BOOT"), constants.DirPerm)
 	if err != nil {
+		i.cfg.Logger.Errorf("creating efi directories: %s", err.Error())
 		return err
 	}
 
@@ -80,6 +90,7 @@ func (i *InstallAction) Run() (err error) {
 	// Copy the efi file into the proper dir
 	_, err = e.DumpSource(i.spec.Partitions.EFI.MountPoint, i.spec.Active.Source)
 	if err != nil {
+		i.cfg.Logger.Errorf("dumping source: %s", err.Error())
 		return err
 	}
 
@@ -126,40 +137,51 @@ func (i *InstallAction) Run() (err error) {
 		return nil
 	})
 	if err != nil {
+		i.cfg.Logger.Errorf("error happened: %s", err.Error())
 		return err
 	}
 
 	for _, role := range []string{"active", "passive", "recovery"} {
 		if err = copyArtifactSetRole(i.cfg.Fs, i.spec.Partitions.EFI.MountPoint, UnassignedArtifactRole, role, i.cfg.Logger); err != nil {
+			i.cfg.Logger.Errorf("installing the new artifact set as %s: %s", role, err.Error())
 			return fmt.Errorf("installing the new artifact set as %s: %w", role, err)
 		}
 	}
 
 	loaderConfPath := filepath.Join(i.spec.Partitions.EFI.MountPoint, "loader", "loader.conf")
 	if err = replaceRoleInKey(loaderConfPath, "default", UnassignedArtifactRole, "active", i.cfg.Logger); err != nil {
+		i.cfg.Logger.Errorf("replacing role in key %s: %s", "default", err.Error())
 		return err
 	}
 
 	if err = removeArtifactSetWithRole(i.cfg.Fs, i.spec.Partitions.EFI.MountPoint, UnassignedArtifactRole); err != nil {
+		i.cfg.Logger.Errorf("removing artifact set with role %s: %s", UnassignedArtifactRole, err.Error())
 		return fmt.Errorf("removing artifact set with role %s: %w", UnassignedArtifactRole, err)
 	}
 
 	err = hook.Run(*i.cfg, i.spec, hook.UKIEncryptionHooks...)
 	if err != nil {
+		i.cfg.Logger.Errorf("running uki encryption hooks: %s", err.Error())
 		return err
 	}
 
 	// after install hook happens after install (this is for compatibility with normal install, so users can reuse their configs)
 	err = Hook(i.cfg, constants.AfterInstallHook)
 	if err != nil {
+		i.cfg.Logger.Errorf("running after install hook: %s", err.Error())
 		return err
 	}
 	// Remove all boot manager entries?
 	// Create boot manager entry
 	// Set default entry to the one we just created
 	// Probably copy efi utils, like the Mokmanager and even the shim or grub efi to help with troubleshooting?
-	_ = utils.RunStage(i.cfg, "kairos-uki-install.after")
-	_ = events.RunHookScript("/usr/bin/kairos-agent.uki.install.after.hook") //nolint:errcheck
+	if err = utils.RunStage(i.cfg, "kairos-uki-install.after"); err != nil {
+		i.cfg.Logger.Errorf("running kairos-uki-install.after stage: %s", err.Error())
+	}
+
+	if err = events.RunHookScript("/usr/bin/kairos-agent.uki.install.after.hook"); err != nil {
+		i.cfg.Logger.Errorf("running kairos-uki-install.after hook script: %s", err.Error())
+	}
 
 	return hook.Run(*i.cfg, i.spec, hook.AfterUkiInstall...)
 }
diff --git a/pkg/uki/reset.go b/pkg/uki/reset.go
index bc2ac14..73d1f01 100644
--- a/pkg/uki/reset.go
+++ b/pkg/uki/reset.go
@@ -24,8 +24,12 @@ func NewResetAction(cfg *config.Config, spec *v1.ResetUkiSpec) *ResetAction {
 
 func (r *ResetAction) Run() (err error) {
 	// Run pre-install stage
-	_ = elementalUtils.RunStage(r.cfg, "kairos-uki-reset.pre")
-	_ = events.RunHookScript("/usr/bin/kairos-agent.uki.reset.pre.hook")
+	if err = elementalUtils.RunStage(r.cfg, "kairos-uki-reset.pre"); err != nil {
+		r.cfg.Logger.Errorf("running kairos-uki-reset.pre stage: %s", err.Error())
+	}
+	if err = events.RunHookScript("/usr/bin/kairos-agent.uki.reset.pre.hook"); err != nil {
+		r.cfg.Logger.Errorf("running kairos-uki-reset.pre hook script: %s", err.Error())
+	}
 
 	e := elemental.NewElemental(r.cfg)
 	cleanup := utils.NewCleanStack()
@@ -34,6 +38,7 @@ func (r *ResetAction) Run() (err error) {
 	// Unmount partitions if any is already mounted before formatting
 	err = e.UnmountPartitions(r.spec.Partitions.PartitionsByMountPoint(true))
 	if err != nil {
+		r.cfg.Logger.Errorf("unmounting partitions: %s", err.Error())
 		return err
 	}
 
@@ -43,6 +48,7 @@ func (r *ResetAction) Run() (err error) {
 		if persistent != nil {
 			err = e.FormatPartition(persistent)
 			if err != nil {
+				r.cfg.Logger.Errorf("formatting persistent partition: %s", err.Error())
 				return err
 			}
 		}
@@ -54,6 +60,7 @@ func (r *ResetAction) Run() (err error) {
 		if oem != nil {
 			err = e.FormatPartition(oem)
 			if err != nil {
+				r.cfg.Logger.Errorf("formatting OEM partition: %s", err.Error())
 				return err
 			}
 		}
@@ -62,6 +69,7 @@ func (r *ResetAction) Run() (err error) {
 	// REMOUNT /efi as RW (its RO by default)
 	umount, err := e.MountRWPartition(r.spec.Partitions.EFI)
 	if err != nil {
+		r.cfg.Logger.Errorf("mounting EFI partition as RW: %s", err.Error())
 		return err
 	}
 	cleanup.Push(umount)
@@ -69,33 +77,43 @@ func (r *ResetAction) Run() (err error) {
 	// Copy "recovery" to "active"
 	err = overwriteArtifactSetRole(r.cfg.Fs, constants.UkiEfiDir, "recovery", "active", r.cfg.Logger)
 	if err != nil {
+		r.cfg.Logger.Errorf("copying recovery to active: %s", err.Error())
 		return fmt.Errorf("copying recovery to active: %w", err)
 	}
 	// SelectBootEntry sets the default boot entry to the selected entry
 	err = action.SelectBootEntry(r.cfg, "active")
 	// Should we fail? Or warn?
 	if err != nil {
+		r.cfg.Logger.Errorf("selecting boot entry : %s", err.Error())
 		return err
 	}
 
 	if mnt, err := elementalUtils.IsMounted(r.cfg, r.spec.Partitions.OEM); !mnt && err == nil {
 		err = e.MountPartition(r.spec.Partitions.OEM)
 		if err != nil {
+			r.cfg.Logger.Errorf("mounting oem partition: %s", err.Error())
 			return err
 		}
 	}
 
 	err = Hook(r.cfg, constants.AfterResetHook)
 	if err != nil {
+		r.cfg.Logger.Errorf("running after install hook: %s", err.Error())
 		return err
 	}
 
-	_ = elementalUtils.RunStage(r.cfg, "kairos-uki-reset.after")
-	_ = events.RunHookScript("/usr/bin/kairos-agent.uki.reset.after.hook") //nolint:errcheck
+	if err = elementalUtils.RunStage(r.cfg, "kairos-uki-reset.after"); err != nil {
+		r.cfg.Logger.Errorf("running kairos-uki-reset.after stage: %s", err.Error())
+	}
+
+	if err = events.RunHookScript("/usr/bin/kairos-agent.uki.reset.after.hook"); err != nil {
+		r.cfg.Logger.Errorf("running kairos-uki-reset.after hook script: %s", err.Error())
+	}
 
 	// Do not reboot/poweroff on cleanup errors
 	err = cleanup.Cleanup(err)
 	if err != nil {
+		r.cfg.Logger.Errorf("running cleanup: %s", err.Error())
 		return err
 	}
 	return nil
diff --git a/pkg/uki/upgrade.go b/pkg/uki/upgrade.go
index 4dbc9c3..6d0a253 100644
--- a/pkg/uki/upgrade.go
+++ b/pkg/uki/upgrade.go
@@ -29,12 +29,18 @@ func (i *UpgradeAction) Run() (err error) {
 	cleanup := utils.NewCleanStack()
 	defer func() { err = cleanup.Cleanup(err) }()
 	// Run pre-install stage
-	_ = elementalUtils.RunStage(i.cfg, "kairos-uki-upgrade.pre")
-	_ = events.RunHookScript("/usr/bin/kairos-agent.uki.upgrade.pre.hook")
+	if err = elementalUtils.RunStage(i.cfg, "kairos-uki-upgrade.pre"); err != nil {
+		i.cfg.Logger.Errorf("running kairos-uki-upgrade.pre stage: %s", err.Error())
+	}
+
+	if err = events.RunHookScript("/usr/bin/kairos-agent.uki.upgrade.pre.hook"); err != nil {
+		i.cfg.Logger.Errorf("running kairos-uki-upgrade.pre hook script: %s", err.Error())
+	}
 
 	// REMOUNT /efi as RW (its RO by default)
 	umount, err := e.MountRWPartition(i.spec.EfiPartition)
 	if err != nil {
+		i.cfg.Logger.Errorf("remounting efi as RW: %s", err.Error())
 		return err
 	}
 	cleanup.Push(umount)
@@ -54,27 +60,32 @@ func (i *UpgradeAction) Run() (err error) {
 	// Dump artifact to efi dir
 	_, err = e.DumpSource(constants.UkiEfiDir, i.spec.Active.Source)
 	if err != nil {
+		i.cfg.Logger.Errorf("dumping the source: %s", err.Error())
 		return err
 	}
 
 	// Rotate first
 	err = overwriteArtifactSetRole(i.cfg.Fs, constants.UkiEfiDir, "active", "passive", i.cfg.Logger)
 	if err != nil {
+		i.cfg.Logger.Errorf("rotating active to passive: %s", err.Error())
 		return fmt.Errorf("rotating active to passive: %w", err)
 	}
 
 	// Install the new artifacts as "active"
 	err = overwriteArtifactSetRole(i.cfg.Fs, constants.UkiEfiDir, UnassignedArtifactRole, "active", i.cfg.Logger)
 	if err != nil {
+		i.cfg.Logger.Errorf("installing the new artifacts as active: %s", err.Error())
 		return fmt.Errorf("installing the new artifacts as active: %w", err)
 	}
 
 	loaderConfPath := filepath.Join(constants.UkiEfiDir, "loader", "loader.conf")
 	if err = replaceRoleInKey(loaderConfPath, "default", UnassignedArtifactRole, "active", i.cfg.Logger); err != nil {
+		i.cfg.Logger.Errorf("replacing role in key: %s", err.Error())
 		return err
 	}
 
 	if err = removeArtifactSetWithRole(i.cfg.Fs, constants.UkiEfiDir, UnassignedArtifactRole); err != nil {
+		i.cfg.Logger.Errorf("removing artifact set: %s", err.Error())
 		return fmt.Errorf("removing artifact set: %w", err)
 	}
 
@@ -82,11 +93,17 @@ func (i *UpgradeAction) Run() (err error) {
 	err = action.SelectBootEntry(i.cfg, "active")
 	// Should we fail? Or warn?
 	if err != nil {
+		i.cfg.Logger.Errorf("selecting boot entry: %s", err.Error())
 		return err
 	}
 
-	_ = elementalUtils.RunStage(i.cfg, "kairos-uki-upgrade.after")
-	_ = events.RunHookScript("/usr/bin/kairos-agent.uki.upgrade.after.hook") //nolint:errcheck
+	if err = elementalUtils.RunStage(i.cfg, "kairos-uki-upgrade.after"); err != nil {
+		i.cfg.Logger.Errorf("running kairos-uki-upgrade.after stage: %s", err.Error())
+	}
+
+	if err = events.RunHookScript("/usr/bin/kairos-agent.uki.upgrade.after.hook"); err != nil {
+		i.cfg.Logger.Errorf("running kairos-uki-upgrade.after hook script: %s", err.Error())
+	}
 
 	return nil
 }
@@ -96,6 +113,7 @@ func (i *UpgradeAction) Run() (err error) {
 func (i *UpgradeAction) installRecovery() error {
 	tmpDir, err := os.MkdirTemp("", "")
 	if err != nil {
+		i.cfg.Logger.Errorf("creating a tmp dir: %s", err.Error())
 		return fmt.Errorf("creating a tmp dir: %w", err)
 	}
 	defer os.RemoveAll(tmpDir)
@@ -104,6 +122,7 @@ func (i *UpgradeAction) installRecovery() error {
 	e := elemental.NewElemental(i.cfg)
 	_, err = e.DumpSource(tmpDir, i.spec.Active.Source)
 	if err != nil {
+		i.cfg.Logger.Errorf("dumping the source to the tmp dir: %s", err.Error())
 		return err
 	}
 
@@ -111,6 +130,7 @@ func (i *UpgradeAction) installRecovery() error {
 		filepath.Join(tmpDir, "EFI", "kairos", UnassignedArtifactRole+".efi"),
 		filepath.Join(constants.UkiEfiDir, "EFI", "kairos", "recovery.efi"))
 	if err != nil {
+		i.cfg.Logger.Errorf("copying efi files: %s", err.Error())
 		return err
 	}
 
@@ -119,15 +139,18 @@ func (i *UpgradeAction) installRecovery() error {
 		filepath.Join(tmpDir, "loader", "entries", UnassignedArtifactRole+".conf"),
 		targetConfPath)
 	if err != nil {
+		i.cfg.Logger.Errorf("copying conf files: %s", err.Error())
 		return err
 	}
 	err = replaceRoleInKey(targetConfPath, "efi", UnassignedArtifactRole, "recovery", i.cfg.Logger)
 	if err != nil {
+		i.cfg.Logger.Errorf("replacing role in in key %s: %s", "efi", err.Error())
 		return err
 	}
 
 	err = replaceConfTitle(targetConfPath, "recovery")
 	if err != nil {
+		i.cfg.Logger.Errorf("replacing conf title: %s", err.Error())
 		return err
 	}