diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 29bb69b..2782321 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -22,7 +22,7 @@ stackctl is a Go CLI tool (Cobra) for managing Kubernetes stack deployments. It
 | `config` | set, get, list, use-context, current-context, delete-context | config.go |
 | `login`/`logout`/`whoami` | top-level; supports password + OIDC loopback flow | login.go |
 | `auth` | register | login.go |
-| `stack` | list, get, create, update, deploy, stop, clean, delete, status, logs, clone, extend, values, compare, history, rollback, history-values, watch | stack.go (TTL and stop-time helpers: ttl.go) |
+| `stack` | list, get, create, update, deploy, stop, clean, delete, status, logs, clone, extend, values, compare, history, rollback, history-values, watch, preview, pods, recent, follow, unfollow | stack.go; preview/pods/recent: stack_inspect.go; follow/unfollow: stack_followers.go; TTL and stop-time helpers: ttl.go |
 | `template` | list, get, create, update, delete, clone, instantiate, quick-deploy, publish, unpublish, update-chart, versions (list, get, diff) | template.go |
 | `definition` | list, get, create, update, delete, export, import, update-chart | definition.go |
 | `override` | list, get, set, unset, delete, branch (list/set/delete), quota (get/set/delete) | override.go |
diff --git a/CLAUDE.md b/CLAUDE.md
index 91a0fa3..d218058 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -28,6 +28,8 @@ cli/                          # Go module root (github.com/omattsson/stackctl/cl
     login.go                  # login, logout, whoami, auth register
     token.go                  # Token helpers (save/load/delete session, fresh token for plugins)
     stack.go                  # stack list/get/create/update/deploy/stop/clean/delete/status/logs/clone/extend/values/compare/history/rollback/history-values/watch
+    stack_inspect.go          # stack preview/pods/recent (deploy-preview, live pods and events, recent)
+    stack_followers.go        # stack follow/unfollow (in-app notifications; not the --follow log flag)
     ttl.go                    # --ttl/--stop-at/--until parsing, TTL limit check (GET /api/v1/ui-config, 30-day fallback), expiry text
     server.go                 # server info (ping, ui-config; public routes, no credentials)
     template.go               # template list/get/create/update/clone/publish/unpublish/versions/instantiate/quick-deploy/delete
diff --git a/README.md b/README.md
index 6197b77..21c54c3 100644
--- a/README.md
+++ b/README.md
@@ -230,7 +230,17 @@ stackctl stack update my-app --ttl 0   # clear the expiry
 
 # Monitor
 stackctl stack status my-app
+stackctl stack pods my-app            # live pods, container reasons (CrashLoopBackOff) and Warning events
 stackctl stack logs my-app
+stackctl stack recent                 # your 5 most recently updated stacks
+
+# Helm values that the next deploy uses (YAML on stdout, warnings on stderr)
+stackctl stack preview my-app
+stackctl stack preview my-app --chart backend > backend-values.yaml
+
+# Get the in-app notifications of a stack (not the --follow flag, which streams a log)
+stackctl stack follow my-app
+stackctl stack unfollow my-app
 stackctl stack watch --id 6a1d2c3b-4e5f-4a6b-8c7d-9e0f1a2b3c4d   # watch uses --id, not a name argument
 
 # Lifecycle
@@ -268,6 +278,8 @@ stackctl stack rollback my-app --target-log <log-id>
 
 `--stop-at` (`stack create`, `clone`, `update`, `template quick-deploy`) sets a fixed stop time: the TTL becomes 0 and the stack stops at that time. `--stop-at` and `--until` accept RFC 3339 (`2026-10-17T18:00:00+02:00`) or a local time without a zone (`2026-10-17 18:00`). stackctl sends the time in UTC. `stack create --ttl 0` now sends 0 (no expiry); without `--ttl` the server applies its default TTL. `--ttl` and `--stop-at` together, a stop time in the past or a bad format are usage errors; stackctl sends no request. Before the request, stackctl also refuses a `--ttl`, a `--stop-at` or an `--until` above the TTL limit of the server (`max_instance_ttl_days` of `GET /api/v1/ui-config`; 30 days for an older server). `stack list` (column `EXPIRES`) and `stack get` show a fixed stop time as `stops at <time>`. A deploy after the stop time fails with 409: set a new stop time or a TTL with `stack update`.
 
+`stack get` shows `Following` and `Followers` (k8s-stack-manager v0.8.0 or later). `stack preview -q` prints the names of the charts whose values differ from the last deploy. `stack preview` writes the values-drift warning to stderr, so the YAML on stdout stays valid.
+
 `stack update --name` must be a DNS label (lowercase a-z, 0-9 and `-`, at most 50 characters). The namespace does not change. When another stack on the cluster has the name, stackctl prints the server message and the free names, for example `Conflict: A stack named "my-app" already exists on this cluster (owner: alice). Free names: my-app-2, my-app-3`. `stack create`, `clone` and `template quick-deploy` print the same message for a name conflict.
 
 `--reset-ttl M` (deprecated) keeps the old behaviour: the TTL becomes M minutes and the expiry now + M minutes, which can be earlier. `--yes` has no effect and is accepted for older scripts.
@@ -639,8 +651,9 @@ cli/
   Makefile                # build, build-all, test, lint, coverage, install
   cmd/                    # Cobra commands, one file per command group
     root.go  resolve.go  paging.go  plugins.go  browser.go  token.go  values.go
-    config.go  login.go  version.go  completion.go
-    stack.go  template.go  definition.go  override.go  bulk.go
+    config.go  login.go  version.go  completion.go  server.go
+    stack.go  stack_inspect.go  stack_followers.go  ttl.go
+    template.go  definition.go  override.go  bulk.go
     cluster.go  git.go  orphaned.go  user.go  apikey.go  audit.go
     analytics.go  cleanup_policy.go  favorite.go  notification.go
     testdata/             # golden files
diff --git a/cli/cmd/paging_test.go b/cli/cmd/paging_test.go
index dbf3b39..9b2741a 100644
--- a/cli/cmd/paging_test.go
+++ b/cli/cmd/paging_test.go
@@ -73,13 +73,16 @@ func makeIDs(n int) []string {
 // resetListFlags resets the shared list flags of cmd when the test ends.
 func resetListFlags(t *testing.T, cmd *cobra.Command) {
 	t.Helper()
-	t.Cleanup(func() {
+	// Reset before the test too: another test can leave a flag Changed.
+	reset := func() {
 		if cmd.Flags().Lookup("mine") != nil {
 			resetFlag(t, cmd.Flags(), "mine", "false")
 		}
 		resetFlag(t, cmd.Flags(), "page", "0")
 		resetFlag(t, cmd.Flags(), flagPageSize, "0")
-	})
+	}
+	reset()
+	t.Cleanup(reset)
 }
 
 func TestListCmds_FooterWhenMoreItems(t *testing.T) {
diff --git a/cli/cmd/stack.go b/cli/cmd/stack.go
index 4cf3909..f6f5f8b 100644
--- a/cli/cmd/stack.go
+++ b/cli/cmd/stack.go
@@ -356,29 +356,34 @@ Examples:
 		case output.FormatYAML:
 			return printer.PrintYAML(resp)
 		default:
-			headers := []string{"ID", "NAME", "STATUS", "OWNER", "BRANCH", "CLUSTER", "DEPLOYED AT", "EXPIRES"}
-			rows := make([][]string, len(resp.Data))
-			for i, s := range resp.Data {
-				cluster := s.ClusterName
-				if cluster == "" && s.ClusterID != nil {
-					cluster = *s.ClusterID
-				}
-				rows[i] = []string{
-					s.ID,
-					s.Name,
-					printer.StatusColor(s.Status),
-					displayName(s.OwnerUsername, s.Owner),
-					s.Branch,
-					cluster,
-					formatTime(s.DeployedAt),
-					expiryText(s.TTLMinutes, s.ExpiresAt),
-				}
-			}
-			return printer.PrintTable(headers, rows)
+			return printStackTable(resp.Data)
 		}
 	},
 }
 
+// printStackTable prints stack instances as the table of "stack list".
+func printStackTable(items []types.StackInstance) error {
+	headers := []string{"ID", "NAME", "STATUS", "OWNER", "BRANCH", "CLUSTER", "DEPLOYED AT", "EXPIRES"}
+	rows := make([][]string, len(items))
+	for i, s := range items {
+		cluster := s.ClusterName
+		if cluster == "" && s.ClusterID != nil {
+			cluster = *s.ClusterID
+		}
+		rows[i] = []string{
+			s.ID,
+			s.Name,
+			printer.StatusColor(s.Status),
+			displayName(s.OwnerUsername, s.Owner),
+			s.Branch,
+			cluster,
+			formatTime(s.DeployedAt),
+			expiryText(s.TTLMinutes, s.ExpiresAt),
+		}
+	}
+	return printer.PrintTable(headers, rows)
+}
+
 var stackGetCmd = &cobra.Command{
 	Use:   "get <name|id>",
 	Short: "Show stack instance details",
@@ -2180,11 +2185,19 @@ func printInstanceWithURLs(instance *types.StackInstance, urls []string) error {
 			{Key: "Namespace", Value: instance.Namespace},
 			{Key: "Cluster", Value: displayNameWithID(instance.ClusterName, clusterID)},
 			{Key: "Definition", Value: displayNameWithID(instance.DefinitionName, instance.StackDefinitionID)},
+		}
+		if instance.Following != nil {
+			fields = append(fields, output.KeyValue{Key: "Following", Value: yesNo(*instance.Following)})
+		}
+		if instance.FollowerCount != nil {
+			fields = append(fields, output.KeyValue{Key: "Followers", Value: strconv.FormatInt(*instance.FollowerCount, 10)})
+		}
+		fields = append(fields, []output.KeyValue{
 			{Key: "TTL", Value: ttlText(instance.TTLMinutes, instance.ExpiresAt)},
 			{Key: "Expires At", Value: expiryText(instance.TTLMinutes, instance.ExpiresAt)},
 			{Key: "Deployed At", Value: formatTime(instance.DeployedAt)},
 			{Key: "Created At", Value: instance.CreatedAt.Format(time.RFC3339)},
-		}
+		}...)
 		if instance.ErrorMessage != "" {
 			fields = append(fields, output.KeyValue{Key: "Error", Value: instance.ErrorMessage})
 		}
diff --git a/cli/cmd/stack_followers.go b/cli/cmd/stack_followers.go
new file mode 100644
index 0000000..d77538f
--- /dev/null
+++ b/cli/cmd/stack_followers.go
@@ -0,0 +1,129 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/omattsson/stackctl/cli/pkg/client"
+	"github.com/omattsson/stackctl/cli/pkg/output"
+	"github.com/omattsson/stackctl/cli/pkg/types"
+	"github.com/spf13/cobra"
+)
+
+// The subcommands are "follow" and "unfollow". The --follow flag of
+// "stack deploy" and "stack logs" streams a log; it is not related.
+
+var stackFollowCmd = &cobra.Command{
+	Use:   "follow <name|id>",
+	Short: "Follow a stack instance and get its notifications",
+	Long: `Follow a stack instance. You then get its in-app notifications (deploy,
+stop, clean, expiry), as the owner does, filtered by your notification
+preferences. Every user who can view a stack can follow it. Following a
+stack that you already follow is not an error.
+
+This is not the --follow flag of "stack deploy" and "stack logs", which
+streams the deployment log.
+
+Examples:
+  stackctl stack follow my-stack
+  stackctl stack follow my-stack -o json`,
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return runSetFollow(args[0], true)
+	},
+}
+
+var stackUnfollowCmd = &cobra.Command{
+	Use:   "unfollow <name|id>",
+	Short: "Stop following a stack instance",
+	Long: `Stop following a stack instance. Unfollowing a stack that you do not
+follow is not an error.
+
+Examples:
+  stackctl stack unfollow my-stack`,
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return runSetFollow(args[0], false)
+	},
+}
+
+// runSetFollow follows or unfollows a stack and prints the new state.
+func runSetFollow(nameOrID string, follow bool) error {
+	c, err := newClient()
+	if err != nil {
+		return err
+	}
+	id, err := resolveStackID(c, nameOrID)
+	if err != nil {
+		return err
+	}
+
+	var state *types.FollowState
+	if follow {
+		state, err = c.FollowStack(id)
+	} else {
+		state, err = c.UnfollowStack(id)
+	}
+	if err != nil {
+		return followError(err)
+	}
+
+	if printer.Quiet {
+		fmt.Fprintln(printer.Writer, id)
+		return nil
+	}
+	switch printer.Format {
+	case output.FormatJSON:
+		return printer.PrintJSON(state)
+	case output.FormatYAML:
+		return printer.PrintYAML(state)
+	default:
+		if state.Following {
+			printer.PrintMessage("You follow stack %s (%s)", id, followerText(state.FollowerCount))
+		} else {
+			printer.PrintMessage("You do not follow stack %s (%s)", id, followerText(state.FollowerCount))
+		}
+		return nil
+	}
+}
+
+// followError adds a hint to the answer of a server without follow
+// support: 404 without a JSON message (no route, before v0.8.0) or 501
+// (following is not configured on the server).
+func followError(err error) error {
+	var apiErr *client.APIError
+	if !errors.As(err, &apiErr) {
+		return err
+	}
+	switch {
+	case apiErr.StatusCode == http.StatusNotFound && apiErr.Message == http.StatusText(http.StatusNotFound):
+		return fmt.Errorf("%w (the server does not support following; upgrade k8s-stack-manager to v0.8.0 or later)", err)
+	case apiErr.StatusCode == http.StatusNotImplemented:
+		return fmt.Errorf("%w (following is not configured on the server)", err)
+	}
+	return err
+}
+
+// followerText returns "1 follower" or "N followers".
+func followerText(n int64) string {
+	if n == 1 {
+		return "1 follower"
+	}
+	return fmt.Sprintf("%d followers", n)
+}
+
+// yesNo returns "yes" or "no".
+func yesNo(b bool) string {
+	if b {
+		return "yes"
+	}
+	return "no"
+}
+
+func init() {
+	stackCmd.AddCommand(stackFollowCmd)
+	stackCmd.AddCommand(stackUnfollowCmd)
+}
diff --git a/cli/cmd/stack_inspect.go b/cli/cmd/stack_inspect.go
new file mode 100644
index 0000000..ba751cd
--- /dev/null
+++ b/cli/cmd/stack_inspect.go
@@ -0,0 +1,311 @@
+package cmd
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/omattsson/stackctl/cli/pkg/client"
+	"github.com/omattsson/stackctl/cli/pkg/output"
+	"github.com/omattsson/stackctl/cli/pkg/types"
+	"github.com/spf13/cobra"
+)
+
+var stackPreviewCmd = &cobra.Command{
+	Use:   "preview <name|id>",
+	Short: "Show the Helm values that the next deploy uses",
+	Long: `Show the merged Helm values that the next deploy of a stack uses, for
+each chart, without a deploy (GET /api/v1/stack-instances/:id/deploy-preview).
+
+The values are the result of the full merge: shared values, chart
+defaults, instance overrides and locked template values, with the template
+variables substituted.
+
+The table output writes YAML to stdout: one document for each chart, with a
+"# chart: <name>" comment line that says whether the values differ from the
+last deploy. With --chart, stdout has only the YAML of that chart, so you
+can write it to a file. Warnings go to stderr: after a rollback, the stored
+overrides can differ from the running values (values_drift), and the next
+deploy applies the stored overrides again.
+
+-q prints the names of the charts whose values differ from the last deploy.
+-o json and -o yaml print the response, with the values of the last deploy
+(previous_values) and the next deploy (pending_values). With --chart, the
+response has only that chart.
+
+Examples:
+  stackctl stack preview my-stack
+  stackctl stack preview my-stack --chart backend > backend-values.yaml
+  stackctl stack preview my-stack -q`,
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		chart, _ := cmd.Flags().GetString("chart")
+
+		c, err := newClient()
+		if err != nil {
+			return err
+		}
+		id, err := resolveStackID(c, args[0])
+		if err != nil {
+			return err
+		}
+
+		preview, err := c.GetDeployPreview(id)
+		if err != nil {
+			return err
+		}
+		if chart != "" {
+			if preview.Charts, err = selectPreviewChart(preview.Charts, chart); err != nil {
+				return err
+			}
+		}
+		if preview.ValuesDrift {
+			warning := preview.Warning
+			if strings.TrimSpace(warning) == "" {
+				warning = types.ValuesDriftWarning
+			}
+			printServerWarning(cmd, warning)
+		}
+
+		if printer.Quiet {
+			for _, ch := range preview.Charts {
+				if ch.HasChanges {
+					fmt.Fprintln(printer.Writer, ch.ChartName)
+				}
+			}
+			return nil
+		}
+		switch printer.Format {
+		case output.FormatJSON:
+			return printer.PrintJSON(preview)
+		case output.FormatYAML:
+			return printer.PrintYAML(preview)
+		}
+
+		if len(preview.Charts) == 0 {
+			fmt.Fprintln(cmd.ErrOrStderr(), "The stack has no charts.")
+			return nil
+		}
+		if chart != "" {
+			fmt.Fprint(printer.Writer, withNewline(preview.Charts[0].PendingValues))
+			return nil
+		}
+		for _, ch := range preview.Charts {
+			change := "no change since the last deploy"
+			switch {
+			case ch.PreviousValues == "":
+				change = "no previous deploy"
+			case ch.HasChanges:
+				change = "changed since the last deploy"
+			}
+			fmt.Fprintf(printer.Writer, "---\n# chart: %s (%s)\n%s", ch.ChartName, change, withNewline(ch.PendingValues))
+		}
+		return nil
+	},
+}
+
+// selectPreviewChart returns the preview of the chart with the given name.
+func selectPreviewChart(charts []types.ChartDeployPreview, name string) ([]types.ChartDeployPreview, error) {
+	names := make([]string, 0, len(charts))
+	for _, ch := range charts {
+		if ch.ChartName == name {
+			return []types.ChartDeployPreview{ch}, nil
+		}
+		names = append(names, ch.ChartName)
+	}
+	return nil, fmt.Errorf("chart %q is not in the stack (charts: %s)", name, strings.Join(names, ", "))
+}
+
+// withNewline returns s with a final newline (empty values stay empty).
+func withNewline(s string) string {
+	if s == "" || strings.HasSuffix(s, "\n") {
+		return s
+	}
+	return s + "\n"
+}
+
+var stackPodsCmd = &cobra.Command{
+	Use:   "pods <name|id>",
+	Short: "Show the live pods and the warning events of a stack",
+	Long: `Show the pods of a stack namespace with their status, and the Warning
+events of the namespace (GET /api/v1/stack-instances/:id/pods).
+
+Unlike "stack status", the server reads the cluster directly (not its
+cache) and adds the events. The REASON column shows why a container waits
+or stopped, for example CrashLoopBackOff or ImagePullBackOff.
+
+--all-events also shows the Normal events. -q prints the pod names. -o json
+and -o yaml print the full response, with the container states, the pod
+conditions and all events.
+
+Examples:
+  stackctl stack pods my-stack
+  stackctl stack pods my-stack --all-events
+  stackctl stack pods my-stack -o json`,
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		allEvents, _ := cmd.Flags().GetBool("all-events")
+
+		c, err := newClient()
+		if err != nil {
+			return err
+		}
+		id, err := resolveStackID(c, args[0])
+		if err != nil {
+			return err
+		}
+
+		status, err := c.GetStackPods(id)
+		if err != nil {
+			return err
+		}
+
+		if printer.Quiet {
+			for _, ch := range status.Charts {
+				for _, p := range ch.Pods {
+					fmt.Fprintln(printer.Writer, p.Name)
+				}
+			}
+			return nil
+		}
+		switch printer.Format {
+		case output.FormatJSON:
+			return printer.PrintJSON(status)
+		case output.FormatYAML:
+			return printer.PrintYAML(status)
+		default:
+			return printPodsTable(status, allEvents)
+		}
+	},
+}
+
+// printPodsTable prints the pods and the events of "stack pods".
+func printPodsTable(status *types.InstanceStatus, allEvents bool) error {
+	now := nowFunc()
+	var rows [][]string
+	for _, ch := range status.Charts {
+		for _, p := range ch.Pods {
+			rows = append(rows, []string{
+				ch.ChartName,
+				p.Name,
+				printer.StatusColor(p.Phase),
+				readyText(p),
+				strconv.Itoa(int(p.RestartCount)),
+				formatAge(p.StartTime, now),
+				client.SanitizeServerText(podReason(p)),
+			})
+		}
+	}
+	if len(rows) == 0 {
+		printer.PrintMessage("No pods found in namespace %s.", status.Namespace)
+	} else if err := printer.PrintTable([]string{"CHART", "POD", "PHASE", "READY", "RESTARTS", "AGE", "REASON"}, rows); err != nil {
+		return err
+	}
+
+	events := make([]types.PodEvent, 0, len(status.Events))
+	for _, ev := range status.Events {
+		if allEvents || ev.Type != "Normal" {
+			events = append(events, ev)
+		}
+	}
+	if len(events) == 0 {
+		return nil
+	}
+	sort.SliceStable(events, func(i, j int) bool { return events[i].LastSeen.After(events[j].LastSeen) })
+	evRows := make([][]string, len(events))
+	for i, ev := range events {
+		last := ev.LastSeen
+		evRows[i] = []string{
+			// Event fields have no fixed format: sanitize all of them.
+			formatAge(&last, now),
+			client.SanitizeServerText(ev.Type),
+			client.SanitizeServerText(ev.Reason),
+			client.SanitizeServerText(ev.Object),
+			strconv.Itoa(int(ev.Count)),
+			client.SanitizeServerText(ev.Message),
+		}
+	}
+	printer.PrintMessage("")
+	printer.PrintMessage("Events:")
+	return printer.PrintTable([]string{"LAST SEEN", "TYPE", "REASON", "OBJECT", "COUNT", "MESSAGE"}, evRows)
+}
+
+// readyText returns "ready/total" containers of a pod, or the pod Ready
+// flag when the server sends no container states.
+func readyText(p types.PodStatus) string {
+	if len(p.ContainerStates) == 0 {
+		return strconv.FormatBool(p.Ready)
+	}
+	ready := 0
+	for _, cs := range p.ContainerStates {
+		if cs.Ready {
+			ready++
+		}
+	}
+	return fmt.Sprintf("%d/%d", ready, len(p.ContainerStates))
+}
+
+// podReason returns the first container reason of a pod (for example
+// CrashLoopBackOff), or "-".
+func podReason(p types.PodStatus) string {
+	for _, cs := range p.ContainerStates {
+		if cs.Reason != "" {
+			return cs.Reason
+		}
+	}
+	return "-"
+}
+
+var stackRecentCmd = &cobra.Command{
+	Use:   "recent",
+	Short: "List your 5 most recently updated stack instances",
+	Long: `List the 5 stack instances that you own and that were updated last
+(GET /api/v1/stack-instances/recent).
+
+Examples:
+  stackctl stack recent
+  stackctl stack recent -q`,
+	Args:         cobra.NoArgs,
+	SilenceUsage: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		c, err := newClient()
+		if err != nil {
+			return err
+		}
+		items, err := c.ListRecentStacks()
+		if err != nil {
+			return err
+		}
+
+		if printer.Quiet {
+			for _, s := range items {
+				fmt.Fprintln(printer.Writer, s.ID)
+			}
+			return nil
+		}
+		switch printer.Format {
+		case output.FormatJSON:
+			return printer.PrintJSON(items)
+		case output.FormatYAML:
+			return printer.PrintYAML(items)
+		default:
+			if len(items) == 0 {
+				printer.PrintMessage("You have no stack instances.")
+				return nil
+			}
+			return printStackTable(items)
+		}
+	},
+}
+
+func init() {
+	stackPreviewCmd.Flags().String("chart", "", "Show only this chart (the chart name); stdout is then plain YAML")
+	stackPodsCmd.Flags().Bool("all-events", false, "Also show the Normal events")
+
+	stackCmd.AddCommand(stackPreviewCmd)
+	stackCmd.AddCommand(stackPodsCmd)
+	stackCmd.AddCommand(stackRecentCmd)
+}
diff --git a/cli/cmd/stack_inspect_test.go b/cli/cmd/stack_inspect_test.go
new file mode 100644
index 0000000..f3bebb7
--- /dev/null
+++ b/cli/cmd/stack_inspect_test.go
@@ -0,0 +1,360 @@
+package cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/omattsson/stackctl/cli/pkg/output"
+	"github.com/omattsson/stackctl/cli/pkg/types"
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// routeServer answers each "METHOD path" with a status and a body, and
+// records the requests. An unknown route fails the test.
+func routeServer(t *testing.T, routes map[string]struct {
+	status int
+	body   string
+}) (*httptest.Server, *[]string) {
+	t.Helper()
+	var seen []string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		key := r.Method + " " + r.URL.Path
+		seen = append(seen, key)
+		rt, ok := routes[key]
+		if !ok {
+			t.Errorf("unexpected request %s", key)
+			w.WriteHeader(http.StatusTeapot)
+			return
+		}
+		if strings.HasPrefix(rt.body, "{") || strings.HasPrefix(rt.body, "[") {
+			w.Header().Set("Content-Type", "application/json")
+		}
+		if rt.status != 0 {
+			w.WriteHeader(rt.status)
+		}
+		_, _ = io.WriteString(w, rt.body)
+	}))
+	t.Cleanup(srv.Close)
+	return srv, &seen
+}
+
+type route = struct {
+	status int
+	body   string
+}
+
+// stderrOf sets a buffer as stderr of cmd for the test.
+func stderrOf(t *testing.T, cmd *cobra.Command) *bytes.Buffer {
+	t.Helper()
+	var buf bytes.Buffer
+	cmd.SetErr(&buf)
+	t.Cleanup(func() { cmd.SetErr(nil) })
+	return &buf
+}
+
+// ---------- stack follow / unfollow ----------
+
+func TestStackFollowCmd(t *testing.T) {
+	tests := []struct {
+		name   string
+		cmd    *cobra.Command
+		method string
+		body   string
+		format string
+		want   string
+	}{
+		{"follow", stackFollowCmd, http.MethodPost, `{"following":true,"follower_count":1}`, "table", "You follow stack 42 (1 follower)\n"},
+		{"unfollow", stackUnfollowCmd, http.MethodDelete, `{"following":false,"follower_count":3}`, "table", "You do not follow stack 42 (3 followers)\n"},
+		{"follow json", stackFollowCmd, http.MethodPost, `{"following":true,"follower_count":2}`, "json", `"follower_count": 2`},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			srv, seen := routeServer(t, map[string]route{
+				tt.method + " /api/v1/stack-instances/42/follow": {body: tt.body},
+			})
+			buf := setupStackTestCmd(t, srv.URL)
+			printer.Format = output.Format(tt.format)
+
+			require.NoError(t, tt.cmd.RunE(tt.cmd, []string{"42"}))
+			assert.Equal(t, []string{tt.method + " /api/v1/stack-instances/42/follow"}, *seen)
+			assert.Contains(t, buf.String(), tt.want)
+		})
+	}
+}
+
+func TestStackFollowCmd_ServerErrors(t *testing.T) {
+	tests := []struct {
+		name string
+		rt   route
+		want string
+	}{
+		{"old server without the route", route{http.StatusNotFound, "404 page not found"}, "upgrade k8s-stack-manager to v0.8.0 or later"},
+		{"not configured", route{http.StatusNotImplemented, `{"error":"Following is not available"}`}, "following is not configured on the server"},
+		{"forbidden", route{http.StatusForbidden, `{"error":"no access"}`}, "Permission denied."},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			srv, _ := routeServer(t, map[string]route{"POST /api/v1/stack-instances/42/follow": tt.rt})
+			_ = setupStackTestCmd(t, srv.URL)
+
+			err := stackFollowCmd.RunE(stackFollowCmd, []string{"42"})
+			require.Error(t, err)
+			assert.Contains(t, err.Error(), tt.want)
+		})
+	}
+}
+
+func TestStackGetCmd_FollowRows(t *testing.T) {
+	following := true
+	count := int64(4)
+	inst := sampleStack()
+	inst.Status = "draft" // no access URL lookup
+	inst.Following = &following
+	inst.FollowerCount = &count
+	data, err := json.Marshal(inst)
+	require.NoError(t, err)
+	srv, _ := routeServer(t, map[string]route{"GET /api/v1/stack-instances/42": {body: string(data)}})
+	buf := setupStackTestCmd(t, srv.URL)
+
+	require.NoError(t, stackGetCmd.RunE(stackGetCmd, []string{"42"}))
+	out := buf.String()
+	assert.Regexp(t, `Following:\s+yes`, out)
+	assert.Regexp(t, `Followers:\s+4`, out)
+}
+
+func TestStackGetCmd_NoFollowRowsOnOldServer(t *testing.T) {
+	inst := sampleStack()
+	inst.Status = "draft"
+	data, err := json.Marshal(inst)
+	require.NoError(t, err)
+	srv, _ := routeServer(t, map[string]route{"GET /api/v1/stack-instances/42": {body: string(data)}})
+	buf := setupStackTestCmd(t, srv.URL)
+
+	require.NoError(t, stackGetCmd.RunE(stackGetCmd, []string{"42"}))
+	assert.NotContains(t, buf.String(), "Following")
+	assert.NotContains(t, buf.String(), "Followers")
+}
+
+// ---------- stack preview ----------
+
+const previewBody = `{"instance_id":"42","instance_name":"my-stack","charts":[` +
+	`{"chart_name":"backend","previous_values":"replicas: 1\n","pending_values":"replicas: 2\n","has_changes":true},` +
+	`{"chart_name":"frontend","previous_values":"a: b","pending_values":"a: b","has_changes":false}]}`
+
+func setupPreview(t *testing.T, body string) (*bytes.Buffer, *bytes.Buffer) {
+	t.Helper()
+	srv, _ := routeServer(t, map[string]route{"GET /api/v1/stack-instances/42/deploy-preview": {body: body}})
+	buf := setupStackTestCmd(t, srv.URL)
+	stderr := stderrOf(t, stackPreviewCmd)
+	resetCmdFlags(t, stackPreviewCmd, "chart")
+	return buf, stderr
+}
+
+func TestStackPreviewCmd_AllCharts(t *testing.T) {
+	buf, stderr := setupPreview(t, previewBody)
+
+	require.NoError(t, stackPreviewCmd.RunE(stackPreviewCmd, []string{"42"}))
+	want := "---\n# chart: backend (changed since the last deploy)\nreplicas: 2\n" +
+		"---\n# chart: frontend (no change since the last deploy)\na: b\n"
+	assert.Equal(t, want, buf.String())
+	assert.Empty(t, stderr.String())
+}
+
+func TestStackPreviewCmd_OneChartIsPlainYAML(t *testing.T) {
+	buf, _ := setupPreview(t, previewBody)
+	require.NoError(t, stackPreviewCmd.Flags().Set("chart", "backend"))
+
+	require.NoError(t, stackPreviewCmd.RunE(stackPreviewCmd, []string{"42"}))
+	assert.Equal(t, "replicas: 2\n", buf.String())
+}
+
+func TestStackPreviewCmd_UnknownChart(t *testing.T) {
+	_, _ = setupPreview(t, previewBody)
+	require.NoError(t, stackPreviewCmd.Flags().Set("chart", "db"))
+
+	err := stackPreviewCmd.RunE(stackPreviewCmd, []string{"42"})
+	require.Error(t, err)
+	assert.Equal(t, `chart "db" is not in the stack (charts: backend, frontend)`, err.Error())
+}
+
+func TestStackPreviewCmd_QuietListsChangedCharts(t *testing.T) {
+	buf, _ := setupPreview(t, previewBody)
+	printer.Quiet = true
+
+	require.NoError(t, stackPreviewCmd.RunE(stackPreviewCmd, []string{"42"}))
+	assert.Equal(t, "backend\n", buf.String())
+}
+
+func TestStackPreviewCmd_DriftWarningOnStderr(t *testing.T) {
+	body := strings.Replace(previewBody, `"charts":[`, `"values_drift":true,"charts":[`, 1)
+	buf, stderr := setupPreview(t, body)
+	require.NoError(t, stackPreviewCmd.Flags().Set("chart", "backend"))
+
+	require.NoError(t, stackPreviewCmd.RunE(stackPreviewCmd, []string{"42"}))
+	assert.Equal(t, "replicas: 2\n", buf.String(), "stdout stays plain YAML")
+	assert.Equal(t, "Warning: "+types.ValuesDriftWarning+"\n", stderr.String())
+}
+
+func TestStackPreviewCmd_NeverDeployed(t *testing.T) {
+	body := `{"charts":[{"chart_name":"api","previous_values":"","pending_values":"x: 1\n","has_changes":true}]}`
+	buf, _ := setupPreview(t, body)
+
+	require.NoError(t, stackPreviewCmd.RunE(stackPreviewCmd, []string{"42"}))
+	assert.Equal(t, "---\n# chart: api (no previous deploy)\nx: 1\n", buf.String())
+}
+
+func TestStackPreviewCmd_NoCharts(t *testing.T) {
+	buf, stderr := setupPreview(t, `{"charts":[]}`)
+
+	require.NoError(t, stackPreviewCmd.RunE(stackPreviewCmd, []string{"42"}))
+	assert.Empty(t, buf.String())
+	assert.Equal(t, "The stack has no charts.\n", stderr.String())
+}
+
+func TestStackPreviewCmd_JSONHasBothValues(t *testing.T) {
+	buf, _ := setupPreview(t, previewBody)
+	printer.Format = output.FormatJSON
+
+	require.NoError(t, stackPreviewCmd.RunE(stackPreviewCmd, []string{"42"}))
+	var got types.DeployPreview
+	require.NoError(t, json.Unmarshal(buf.Bytes(), &got))
+	require.Len(t, got.Charts, 2)
+	assert.Equal(t, "replicas: 1\n", got.Charts[0].PreviousValues)
+	assert.Equal(t, "replicas: 2\n", got.Charts[0].PendingValues)
+}
+
+// ---------- stack pods ----------
+
+func podsBody(t *testing.T) string {
+	t.Helper()
+	start := time.Date(2026, 10, 15, 11, 0, 0, 0, time.UTC)
+	status := types.InstanceStatus{
+		Namespace: "stack-demo",
+		Charts: []types.ChartStatus{{
+			ChartName: "backend",
+			Pods: []types.PodStatus{
+				{Name: "backend-1", Phase: "Running", Ready: true, StartTime: &start,
+					ContainerStates: []types.ContainerStateInfo{{Name: "app", Ready: true}, {Name: "sidecar", Ready: true}}},
+				{Name: "backend-2", Phase: "Running", RestartCount: 7, StartTime: &start,
+					ContainerStates: []types.ContainerStateInfo{{Name: "app", Reason: "CrashLoopBackOff"}, {Name: "sidecar", Ready: true}}},
+			},
+		}},
+		Events: []types.PodEvent{
+			{Type: "Normal", Reason: "Pulled", Object: "Pod/backend-1", Count: 1, LastSeen: start},
+			{Type: "Warning", Reason: "BackOff", Object: "Pod/backend-2", Count: 18, LastSeen: start.Add(50 * time.Minute), Message: "Back-off\x1b[2J restarting"},
+			{Type: "Warning", Reason: "Evil\x1b]0;x\x07", Object: "Pod/\tbad", Count: 1, LastSeen: start.Add(40 * time.Minute)},
+		},
+	}
+	data, err := json.Marshal(status)
+	require.NoError(t, err)
+	return string(data)
+}
+
+func setupPods(t *testing.T) *bytes.Buffer {
+	t.Helper()
+	useExpiryClock(t) // 2026-10-15T12:00Z
+	srv, _ := routeServer(t, map[string]route{"GET /api/v1/stack-instances/42/pods": {body: podsBody(t)}})
+	buf := setupStackTestCmd(t, srv.URL)
+	resetCmdFlags(t, stackPodsCmd, "all-events")
+	return buf
+}
+
+func TestStackPodsCmd_Table(t *testing.T) {
+	buf := setupPods(t)
+
+	require.NoError(t, stackPodsCmd.RunE(stackPodsCmd, []string{"42"}))
+	out := buf.String()
+	assert.Regexp(t, `backend\s+backend-1\s+Running\s+2/2\s+0\s+1h\s+-`, out)
+	assert.Regexp(t, `backend\s+backend-2\s+Running\s+1/2\s+7\s+1h\s+CrashLoopBackOff`, out)
+	assert.Contains(t, out, "Events:")
+	assert.Regexp(t, `10m\s+Warning\s+BackOff\s+Pod/backend-2\s+18\s+Back-off \[2J restarting`, out, "the message is sanitized")
+	assert.NotContains(t, out, "Pulled", "Normal events need --all-events")
+	assert.NotContains(t, out, "\x1b", "no escape character reaches the terminal")
+	assert.NotContains(t, out, "\x07")
+	assert.Contains(t, out, "Evil ]0;x")
+}
+
+func TestStackPodsCmd_JSON(t *testing.T) {
+	buf := setupPods(t)
+	printer.Format = output.FormatJSON
+
+	require.NoError(t, stackPodsCmd.RunE(stackPodsCmd, []string{"42"}))
+	var got types.InstanceStatus
+	require.NoError(t, json.Unmarshal(buf.Bytes(), &got))
+	assert.Len(t, got.Events, 3, "-o json keeps all events")
+	assert.Equal(t, "CrashLoopBackOff", got.Charts[0].Pods[1].ContainerStates[0].Reason)
+}
+
+func TestStackPodsCmd_AllEvents(t *testing.T) {
+	buf := setupPods(t)
+	require.NoError(t, stackPodsCmd.Flags().Set("all-events", "true"))
+
+	require.NoError(t, stackPodsCmd.RunE(stackPodsCmd, []string{"42"}))
+	out := buf.String()
+	assert.Contains(t, out, "Pulled")
+	assert.Less(t, strings.Index(out, "BackOff"), strings.Index(out, "Pulled"), "the newest event comes first")
+}
+
+func TestStackPodsCmd_Quiet(t *testing.T) {
+	buf := setupPods(t)
+	printer.Quiet = true
+
+	require.NoError(t, stackPodsCmd.RunE(stackPodsCmd, []string{"42"}))
+	assert.Equal(t, "backend-1\nbackend-2\n", buf.String())
+}
+
+func TestStackPodsCmd_NoPods(t *testing.T) {
+	srv, _ := routeServer(t, map[string]route{"GET /api/v1/stack-instances/42/pods": {body: `{"namespace":"stack-demo","charts":[]}`}})
+	buf := setupStackTestCmd(t, srv.URL)
+	resetCmdFlags(t, stackPodsCmd, "all-events")
+
+	require.NoError(t, stackPodsCmd.RunE(stackPodsCmd, []string{"42"}))
+	assert.Equal(t, "No pods found in namespace stack-demo.\n", buf.String())
+}
+
+// ---------- stack recent ----------
+
+func TestStackRecentCmd(t *testing.T) {
+	inst := sampleStack()
+	data, err := json.Marshal([]types.StackInstance{inst})
+	require.NoError(t, err)
+
+	t.Run("table", func(t *testing.T) {
+		srv, _ := routeServer(t, map[string]route{"GET /api/v1/stack-instances/recent": {body: string(data)}})
+		buf := setupStackTestCmd(t, srv.URL)
+		require.NoError(t, stackRecentCmd.RunE(stackRecentCmd, nil))
+		assert.Contains(t, buf.String(), "EXPIRES")
+		assert.Contains(t, buf.String(), inst.Name)
+	})
+	t.Run("quiet", func(t *testing.T) {
+		srv, _ := routeServer(t, map[string]route{"GET /api/v1/stack-instances/recent": {body: string(data)}})
+		buf := setupStackTestCmd(t, srv.URL)
+		printer.Quiet = true
+		require.NoError(t, stackRecentCmd.RunE(stackRecentCmd, nil))
+		assert.Equal(t, inst.ID+"\n", buf.String())
+	})
+	t.Run("json", func(t *testing.T) {
+		srv, _ := routeServer(t, map[string]route{"GET /api/v1/stack-instances/recent": {body: string(data)}})
+		buf := setupStackTestCmd(t, srv.URL)
+		printer.Format = output.FormatJSON
+		require.NoError(t, stackRecentCmd.RunE(stackRecentCmd, nil))
+		var got []types.StackInstance
+		require.NoError(t, json.Unmarshal(buf.Bytes(), &got))
+		require.Len(t, got, 1)
+		assert.Equal(t, inst.ID, got[0].ID)
+	})
+	t.Run("empty", func(t *testing.T) {
+		srv, _ := routeServer(t, map[string]route{"GET /api/v1/stack-instances/recent": {body: `[]`}})
+		buf := setupStackTestCmd(t, srv.URL)
+		require.NoError(t, stackRecentCmd.RunE(stackRecentCmd, nil))
+		assert.Equal(t, "You have no stack instances.\n", buf.String())
+	})
+}
diff --git a/cli/cmd/stack_test.go b/cli/cmd/stack_test.go
index 8e9e508..c21ca5c 100644
--- a/cli/cmd/stack_test.go
+++ b/cli/cmd/stack_test.go
@@ -1760,8 +1760,8 @@ func TestStackListCmd_PageAndPageSize(t *testing.T) {
 	stackListCmd.Flags().Set("page", "2")
 	stackListCmd.Flags().Set("page-size", "10")
 	t.Cleanup(func() {
-		stackListCmd.Flags().Set("page", "0")
-		stackListCmd.Flags().Set("page-size", "0")
+		resetFlag(t, stackListCmd.Flags(), "page", "0")
+		resetFlag(t, stackListCmd.Flags(), "page-size", "0")
 	})
 
 	err := stackListCmd.RunE(stackListCmd, []string{})
diff --git a/cli/pkg/client/client.go b/cli/pkg/client/client.go
index dd8f6ae..83ac305 100644
--- a/cli/pkg/client/client.go
+++ b/cli/pkg/client/client.go
@@ -624,6 +624,56 @@ func (c *Client) ListStacks(params map[string]string) (*types.ListResponse[types
 	return &resp, nil
 }
 
+// FollowStack makes the caller follow a stack instance (idempotent).
+func (c *Client) FollowStack(id string) (*types.FollowState, error) {
+	var state types.FollowState
+	if err := c.Post(fmt.Sprintf("/api/v1/stack-instances/%s/follow", id), nil, &state); err != nil {
+		return nil, err
+	}
+	return &state, nil
+}
+
+// UnfollowStack stops the caller from following a stack instance
+// (idempotent).
+func (c *Client) UnfollowStack(id string) (*types.FollowState, error) {
+	var state types.FollowState
+	if err := c.doJSON(http.MethodDelete, fmt.Sprintf("/api/v1/stack-instances/%s/follow", id), nil, &state); err != nil {
+		return nil, err
+	}
+	return &state, nil
+}
+
+// GetDeployPreview returns the merged values that the next deploy of a
+// stack instance uses, for each chart, without a deploy.
+func (c *Client) GetDeployPreview(id string) (*types.DeployPreview, error) {
+	var preview types.DeployPreview
+	if err := c.Get(fmt.Sprintf("/api/v1/stack-instances/%s/deploy-preview", id), &preview); err != nil {
+		return nil, err
+	}
+	return &preview, nil
+}
+
+// GetStackPods returns the live pod status of a stack namespace, with the
+// namespace events (GET /api/v1/stack-instances/:id/pods). Unlike
+// GetStackStatus, the server reads the cluster directly.
+func (c *Client) GetStackPods(id string) (*types.InstanceStatus, error) {
+	var status types.InstanceStatus
+	if err := c.Get(fmt.Sprintf("/api/v1/stack-instances/%s/pods", id), &status); err != nil {
+		return nil, err
+	}
+	return &status, nil
+}
+
+// ListRecentStacks returns the 5 most recently updated stack instances of
+// the caller (GET /api/v1/stack-instances/recent).
+func (c *Client) ListRecentStacks() ([]types.StackInstance, error) {
+	var instances []types.StackInstance
+	if err := c.Get("/api/v1/stack-instances/recent", &instances); err != nil {
+		return nil, err
+	}
+	return instances, nil
+}
+
 // GetStack returns a single stack instance by ID.
 func (c *Client) GetStack(id string) (*types.StackInstance, error) {
 	var instance types.StackInstance
diff --git a/cli/pkg/client/stack_inspect_test.go b/cli/pkg/client/stack_inspect_test.go
new file mode 100644
index 0000000..a59b2ca
--- /dev/null
+++ b/cli/pkg/client/stack_inspect_test.go
@@ -0,0 +1,64 @@
+package client
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// oneRoute answers one method and path with body; other requests fail.
+func oneRoute(t *testing.T, method, path, body string) *Client {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != method || r.URL.Path != path {
+			t.Errorf("unexpected %s %s", r.Method, r.URL.Path)
+			w.WriteHeader(http.StatusTeapot)
+			return
+		}
+		data, _ := io.ReadAll(r.Body)
+		assert.Empty(t, data, "no request body")
+		_, _ = io.WriteString(w, body)
+	}))
+	t.Cleanup(srv.Close)
+	return New(srv.URL)
+}
+
+func TestFollowAndUnfollowStack(t *testing.T) {
+	t.Parallel()
+	st, err := oneRoute(t, http.MethodPost, "/api/v1/stack-instances/42/follow", `{"following":true,"follower_count":2}`).FollowStack("42")
+	require.NoError(t, err)
+	assert.True(t, st.Following)
+	assert.Equal(t, int64(2), st.FollowerCount)
+
+	st, err = oneRoute(t, http.MethodDelete, "/api/v1/stack-instances/42/follow", `{"following":false,"follower_count":1}`).UnfollowStack("42")
+	require.NoError(t, err)
+	assert.False(t, st.Following)
+	assert.Equal(t, int64(1), st.FollowerCount)
+}
+
+func TestGetDeployPreview(t *testing.T) {
+	t.Parallel()
+	p, err := oneRoute(t, http.MethodGet, "/api/v1/stack-instances/42/deploy-preview",
+		`{"instance_id":"42","values_drift":true,"warning":"w","charts":[{"chart_name":"api","pending_values":"a: 1","has_changes":true}]}`).GetDeployPreview("42")
+	require.NoError(t, err)
+	assert.True(t, p.ValuesDrift)
+	require.Len(t, p.Charts, 1)
+	assert.Equal(t, "a: 1", p.Charts[0].PendingValues)
+}
+
+func TestGetStackPodsAndRecent(t *testing.T) {
+	t.Parallel()
+	st, err := oneRoute(t, http.MethodGet, "/api/v1/stack-instances/42/pods",
+		`{"namespace":"ns","charts":[{"chart_name":"api","pods":[{"name":"p1"}]}],"events":[{"type":"Warning","reason":"BackOff"}]}`).GetStackPods("42")
+	require.NoError(t, err)
+	assert.Equal(t, "p1", st.Charts[0].Pods[0].Name)
+	assert.Equal(t, "BackOff", st.Events[0].Reason)
+
+	items, err := oneRoute(t, http.MethodGet, "/api/v1/stack-instances/recent", `[{"id":"1"},{"id":"2"}]`).ListRecentStacks()
+	require.NoError(t, err)
+	assert.Len(t, items, 2)
+}
diff --git a/cli/pkg/types/types.go b/cli/pkg/types/types.go
index 441c60b..c7f0446 100644
--- a/cli/pkg/types/types.go
+++ b/cli/pkg/types/types.go
@@ -44,6 +44,36 @@ type StackInstance struct {
 	ErrorMessage      string     `json:"error_message,omitempty" yaml:"error_message,omitempty"`
 	ValuesDrift       bool       `json:"values_drift,omitempty" yaml:"values_drift,omitempty"`
 	Warning           string     `json:"warning,omitempty" yaml:"warning,omitempty"`
+	// Following and FollowerCount come only from GET
+	// /api/v1/stack-instances/:id (nil on other responses and older servers).
+	Following     *bool  `json:"following,omitempty" yaml:"following,omitempty"`
+	FollowerCount *int64 `json:"follower_count,omitempty" yaml:"follower_count,omitempty"`
+}
+
+// FollowState is the response of POST and DELETE
+// /api/v1/stack-instances/:id/follow.
+type FollowState struct {
+	Following     bool  `json:"following" yaml:"following"`
+	FollowerCount int64 `json:"follower_count" yaml:"follower_count"`
+}
+
+// DeployPreview is the response of GET
+// /api/v1/stack-instances/:id/deploy-preview: the values of the last deploy
+// and the values that the next deploy uses, for each chart.
+type DeployPreview struct {
+	InstanceID   string               `json:"instance_id" yaml:"instance_id"`
+	InstanceName string               `json:"instance_name" yaml:"instance_name"`
+	Charts       []ChartDeployPreview `json:"charts" yaml:"charts"`
+	ValuesDrift  bool                 `json:"values_drift" yaml:"values_drift"`
+	Warning      string               `json:"warning,omitempty" yaml:"warning,omitempty"`
+}
+
+// ChartDeployPreview is the preview of one chart. The values are YAML text.
+type ChartDeployPreview struct {
+	ChartName      string `json:"chart_name" yaml:"chart_name"`
+	PreviousValues string `json:"previous_values" yaml:"previous_values"`
+	PendingValues  string `json:"pending_values" yaml:"pending_values"`
+	HasChanges     bool   `json:"has_changes" yaml:"has_changes"`
 }
 
 // ValuesDriftWarning is a copy of the server constant msgValuesDrift