# Why a pod restart is not a clean PostgreSQL recovery

> **Quick answer:** "The pod restarted" describes six different events below, and
> they leave the database in different states. The outcome depends on whether
> PostgreSQL finished its shutdown before it was killed. Sending a signal does
> not settle that. The same `kubectl delete --force --grace-period=0` produced a
> clean shutdown on an idle replica and a crash on a busy one.

## What is the problem?

`kubectl get pods` says `Running` afterwards in both cases, so the difference is
not visible there.

PostgreSQL records how it stopped in its control file. Two values matter here:

- A clean state, such as `shut down` or `shut down in recovery`. PostgreSQL
  recorded a completed shutdown. That is evidence that the next start will not
  need crash recovery. It does not describe what happened at the Kubernetes
  level, and several controlled shutdown paths produce it.
- `in production`, or on a standby `in archive recovery`. PostgreSQL did not
  finish the clean-shutdown transition before the server stopped. The next
  start normally runs crash recovery. The state alone does not say whether the
  cause was a `SIGKILL`, an out-of-memory kill, an I/O failure, a panic, a lost
  node or an exhausted grace period.

The result depends on whether PostgreSQL completed its shutdown protocol before
it was forcibly terminated. Signal delivery is neither necessary nor
sufficient: a signal can arrive and be followed by a `SIGKILL` before shutdown
finishes, and PostgreSQL's own immediate shutdown mode is signal-driven and
deliberately unclean.

### The control file and the startup log are two different vocabularies

Pages that mix the two are easy to misread. The difference is easier to see
outside Kubernetes. Measured on 2026-09-20 on a stock `postgres:18.1` container
on a named Docker volume, Docker 29.1.3:

| what was done | `pg_controldata` while the server was down | what the next start logged |
|---|---|---|
| `docker stop -t 60`, a fast shutdown that completed | `shut down` | `database system was shut down at 2026-09-20 06:15:48 UTC` |
| `docker kill -s KILL` | `in production` | `database system was not properly shut down; automatic recovery in progress` |

Those are different strings from different places. `Database cluster state` is
a field in the control file, and there are only a handful of values. `database
system was not properly shut down` is a log line the next start writes after
reading that field.

The control file is readable at any time, including while the server is
running. It then reports the current state rather than the previous shutdown.
Measured on 2026-09-20 on PostgreSQL 18.6 in a stock `postgres:18.6` container,
after a `SIGKILL` to the postmaster and a restart, `pg_controldata` read
`Database cluster state: in production` while that same restart's log read
`database system was not properly shut down; automatic recovery in progress`.
In Kubernetes the container restarts immediately, so the startup log is what
you get. That is what the table below reports, and it is labelled as such.

## The bench

Everything below was measured on 2026-09-20 on CloudNativePG 1.30.0 running
PostgreSQL 18.1 (Debian 18.1-1.pgdg11+2), a three-instance `Cluster` on a k3d
v5.9.0 cluster (k3s v1.35.5-k3s1) with three agent nodes, on a host with 8 vCPUs
and 62 GB of RAM running Linux 6.17.0-1022-azure under Docker 29.1.3.

Read on 2026-09-20 from that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d
cluster, each instance's `PersistentVolumeClaim` has a request and a reported
capacity of `2Gi`, and nothing enforces it: the k3d local-path provisioner backs
the claim with a directory on the node's own root filesystem, which `df` inside
the pod reports as 495 GB on that same cluster on that same day. The data
directory
can therefore grow past the request without complaint. Measured on 2026-09-20
on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, the data directory
was 1816 MB, and `pg_rewind` reports source directories of 2292 MB and 2788 MB
further down this page. Read the `2Gi` as a number in the manifest, not as a
limit reached by any measurement here.

The settings that change these results, read on 2026-09-20 from that running
CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster: `checkpoint_timeout`
900 s, `max_wal_size` 2048 MB, `shared_buffers` 16384 (128 MB),
`full_page_writes` on, `data_checksums` on, `wal_log_hints` on,
`synchronous_commit` on with no synchronous standby configured, so replication
is asynchronous.

The operator defaults, read on 2026-09-20 from that same CloudNativePG 1.30.0
and PostgreSQL 18.1 k3d cluster: `smartShutdownTimeout` 180 s, `stopDelay` 1800 s,
`switchoverDelay` 3600 s, `failoverDelay` 0 s, and a pod
`terminationGracePeriodSeconds` of 1800.

Storage is the k3d local-path provisioner, so this is local disk, not
network-attached storage. That affects every elapsed time on this page.

## The six events, measured

Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d
cluster. The middle column quotes the next start's log, because the container
was back before the control file could be read:

| what was done | what the next start logged | recovery on the next start | rewind |
|---|---|---|---|
| `kubectl delete pod` on an idle replica, default grace | clean, `shut down in recovery` | entered standby, replayed from the last restartpoint, consistent immediately | not applicable |
| the same with `--force --grace-period=0`, idle replica | clean, `shut down in recovery` | the same | not applicable |
| the same command, replica holding one open session | **unclean**, `interrupted while in recovery` | recovery | not applicable |
| `SIGKILL` to the postmaster, container restarts in place | **unclean** | recovery, and `RESTARTS` became 1 | not applicable |
| `--force --grace-period=0` on an **idle primary** | clean, `shut down at 05:12:29 UTC` | entered standby after failover | ran, and reported `no rewind required` |
| node stopped with the primary on it, mid-write | **unclean**, `was not properly shut down` | replay, 3.49 s | 1964 MB of a 2292 MB source directory |

Two rows in that table need more explanation.

### The same command, two outcomes

This result is easy to overstate. Measured on 2026-09-20 on that CloudNativePG 1.30.0 and
PostgreSQL 18.1 k3d cluster, `kubectl delete pod app-db-3 --force
--grace-period=0` against an idle replica left a clean control file. The
instance manager completed its work inside the available window.

Then the same command, against the same replica, with a single
`SELECT pg_sleep(300)` open:

```
LOG:  database system was interrupted while in recovery at log time 2026-09-20 05:10:05 UTC
LOG:  entering standby mode
LOG:  redo starts at 0/1A6BBB80
LOG:  consistent recovery state reached at 0/2B8BB7A8
LOG:  invalid record length at 0/2B8EFD30: expected at least 24, got 0
```

One open session was the difference between a recorded clean shutdown and a
crash. CloudNativePG's shutdown issues a checkpoint, then disallows new
connections and waits for existing ones. A zero grace period does not leave
much time for that sequence.

> "The instance manager first issues a `CHECKPOINT`, then initiates a **smart**
> shut down, disallowing any new connection to PostgreSQL."
> ([CloudNativePG 1.30, instance manager](https://cloudnative-pg.io/docs/1.30/instance_manager/), read on 2026-09-20)

`--force` changes Kubernetes deletion semantics, not PostgreSQL semantics. The
database still records the result. Kubernetes removes the object without
waiting, and the database gets whatever the node manages before the kill.
`kubectl` prints the warning itself. Run on 2026-09-20 against that k3d cluster,
the command's own output was:

```
Warning: Immediate deletion does not wait for confirmation that the running
resource has been terminated. The resource may continue to run on the cluster
indefinitely.
```

The Kubernetes documentation describes this behaviour.

> "Force deletions do not wait for confirmation from the kubelet that the Pod
> has been terminated."
> ([Kubernetes, force delete StatefulSet pods](https://kubernetes.io/docs/tasks/run-application/force-delete-stateful-set-pod/), read on 2026-09-20)

On the grace period itself:

> "The practice of setting a `pod.Spec.TerminationGracePeriodSeconds` of 0
> seconds is unsafe and strongly discouraged for StatefulSet Pods."
> ([Kubernetes, force delete StatefulSet pods](https://kubernetes.io/docs/tasks/run-application/force-delete-stateful-set-pod/), read on 2026-09-20)

A force-deleted pod can leave its process running on an unreachable node while
a replacement carries the same identity. The Kubernetes documentation describes
the outcome and the possible damage.

> "Irrespective of whether a force deletion is successful in killing a Pod, it
> will immediately free up the name from the apiserver."
> ([Kubernetes, force delete StatefulSet pods](https://kubernetes.io/docs/tasks/run-application/force-delete-stateful-set-pod/), read on 2026-09-20)

The next sentence on the same page explains what the freed name allows.

> "This would let the StatefulSet controller create a replacement Pod with that
> same identity; this can lead to the duplication of a still-running Pod, and if
> said Pod can still communicate with the other members of the StatefulSet, will
> violate the at most one semantics that StatefulSet is designed to guarantee."
> ([Kubernetes, force delete StatefulSet pods](https://kubernetes.io/docs/tasks/run-application/force-delete-stateful-set-pod/), read on 2026-09-20)

The page also discusses databases.

> "Having multiple members with the same identity can be disastrous and may lead
> to data loss (e.g. split brain scenario in quorum-based systems)."
> ([Kubernetes, force delete StatefulSet pods](https://kubernetes.io/docs/tasks/run-application/force-delete-stateful-set-pod/), read on 2026-09-20)

Neither test here produced that result because every node was reachable. This
bench does not test how often the case occurs.

### A clean shutdown still means recovery

"Clean" does not mean "nothing to replay". Measured on 2026-09-20 on that
CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, the cleanly deleted
replica still logged `entering standby mode` and `redo starts at 0/1A6BBB80`
before it was consistent. A standby that stops cleanly resumes replaying
whatever it had received and then catches up with whatever it missed. Startup
time also includes scheduling, volume attachment, the operator's orchestration
and the checkpoint the instance manager takes on the way down.

A clean shutdown rules out crash recovery. That is narrower than saying it
"comes back in seconds".

## What crash recovery actually cost

Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d
cluster, with the primary taking a bulk insert when its node was stopped:

```
LOG:  database system was interrupted; last known up at 2026-09-20 05:12:31 UTC
LOG:  database system was not properly shut down; automatic recovery in progress
LOG:  redo starts at 0/2C0001A8
LOG:  redo done at 0/5DFFFD90 system usage: CPU: user: 2.68 s, system: 0.65 s, elapsed: 3.49 s
LOG:  checkpoint complete: wrote 16384 buffers (100.0%), ... distance=819199 kB
```

Replay work is driven by WAL since the last completed checkpoint, not by
database size. Measured on 2026-09-20 on that CloudNativePG 1.30.0 and
PostgreSQL 18.1 k3d cluster, the checkpoint distance was 819199 kB and replay
took 3.49 seconds.
Elapsed time also depends on storage latency, CPU, WAL availability,
full-page images and the end-of-recovery flush. WAL volume bounds the work but
does not determine the time.

`checkpoint_timeout` and `max_wal_size` are the main levers on how much WAL
can accumulate, but not the only ones. PostgreSQL describes the first effect
directly.

> "Increasing this parameter can increase the amount of time needed for crash
> recovery."
> ([PostgreSQL 18, Write Ahead Log](https://www.postgresql.org/docs/18/runtime-config-wal.html), read on 2026-09-20)

It also says the second is not a ceiling.

> "This is a soft limit; WAL size can exceed `max_wal_size` under special
> circumstances, such as heavy load, a failing `archive_command` or
> `archive_library`, or a high `wal_keep_size` setting."
> ([PostgreSQL 18, Write Ahead Log](https://www.postgresql.org/docs/18/runtime-config-wal.html), read on 2026-09-20)

Crash recovery can be followed by a large checkpoint. In this run it wrote
16,384 buffers, which was all of `shared_buffers`. Whether that becomes a burst
depends on the pacing settings, the dirty-buffer volume and the device, so
measure it on your own storage.

`invalid record length at 0/2B8EFD30: expected at least 24, got 0` is normally
benign at the expected end of WAL: it means no complete next record begins
there, which is how replay finds the end. Treat it as benign only in that
context. The same message earlier in required WAL, or alongside checksum errors
or a missing segment, is a real recovery failure.

## `pg_rewind`, and when it is not the answer

A promoted replica starts a new timeline. If the old primary wrote anything past
the fork point, those writes are not in the new history and the two have
diverged. `pg_rewind` lets a diverged member rejoin without a full rebuild.

> "pg_rewind is a tool for synchronizing a PostgreSQL cluster with another copy
> of the same cluster, after the clusters' timelines have diverged."
> ([PostgreSQL 18, `pg_rewind`](https://www.postgresql.org/docs/18/app-pgrewind.html), read on 2026-09-20)

It is not required after every disruption. Measured on 2026-09-20 on
that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, the force-deleted
idle primary came back to this:

```
pg_rewind: servers diverged at WAL location 0/2C0000A0 on timeline 1
pg_rewind: no rewind required
```

The operator ran the tool; there was nothing to copy. The primary killed
mid-write was different:

```
pg_rewind: servers diverged at WAL location 0/5DFFFDD0 on timeline 2
pg_rewind: rewinding from last common checkpoint at 0/2C000200 on timeline 2
pg_rewind: need to copy 1964 MB (total source directory size is 2292 MB)
pg_rewind: Done!
```

That is 86 percent of the source directory, and a second run of the same test on
2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster copied
2433 MB of 2788 MB. Do not treat those as a
rule. `pg_rewind` copies changed blocks plus certain whole files, so the volume
tracks how much diverged, and these runs diverged during a bulk insert that
dirtied nearly everything.

> "pg_rewind examines the timeline histories of the source and target clusters
> to determine the point where they diverged, and expects to find WAL in the
> target cluster's `pg_wal` directory reaching all the way back to the point of
> divergence."
> ([PostgreSQL 18, `pg_rewind`](https://www.postgresql.org/docs/18/app-pgrewind.html), read on 2026-09-20)

### The prerequisites, which decide whether you get this path at all

The requirement is stated on the tool's own page.

> "pg_rewind requires that the target server either has the wal_log_hints option
> enabled in postgresql.conf or data checksums enabled when the cluster was
> initialized with initdb (the default). full_page_writes must also be set to
> on, but is enabled by default."
> ([PostgreSQL 18, `pg_rewind`](https://www.postgresql.org/docs/18/app-pgrewind.html), read on 2026-09-20)

Note "(the default)", because it is easy to credit the operator with all three.
Measured on 2026-09-20 on a stock `postgres:18.1` container under Docker 29.1.3,
with nothing configured: `data_checksums` on, `full_page_writes` on,
`wal_log_hints` **off**. Measured on 2026-09-20 on that CloudNativePG 1.30.0 and
PostgreSQL 18.1 k3d cluster, all three were on. A stock PostgreSQL 18 therefore
satisfies the prerequisite through checksums. `wal_log_hints` is the setting the
operator added, and it is a second route to the same requirement.

On a cluster you did not build, read both settings rather than assuming the
`initdb` default survived, and remember that turning checksums on afterwards is
not a reload.

> "The server must be shut down cleanly before running pg_checksums."
> ([PostgreSQL 18, `pg_checksums`](https://www.postgresql.org/docs/18/app-pgchecksums.html), read on 2026-09-20)

If local WAL has been recycled past the fork point, rewind needs the archive,
through `-c` or `--restore-target-wal`. If it cannot get there, the fallback is
not a smaller rewind.

> "If pg_rewind fails while processing, then the data folder of the target is
> likely not in a state that can be recovered. In such a case, taking a new
> fresh backup is recommended."
> ([PostgreSQL 18, `pg_rewind`](https://www.postgresql.org/docs/18/app-pgrewind.html), read on 2026-09-20)

Slow incidents usually come from a missing prerequisite or missing WAL followed
by rebuilding a replica from a backup, rather than from a large rewind. Rewind
also leaves WAL to replay before the member is consistent, and it reads from
somewhere: in these runs it read from the live promoted primary, so it used
that instance's read I/O and network. `pg_rewind` can instead read a source data
directory on disk, and the documentation attaches one condition to that.

> "Specifies the file system path to the data directory of the source server to
> synchronize the target with. This option requires the source server to be
> cleanly shut down."
> ([PostgreSQL 18, `pg_rewind`](https://www.postgresql.org/docs/18/app-pgrewind.html), read on 2026-09-20)

Whether rejoin competes with production traffic depends on how the command is
invoked. The offline route needs a stopped source, which a live primary is not.
Under an operator you do not choose this: CloudNativePG ran the live-source form
in every run on this page.

## Failover, and what it costs you

Deleting a primary pod is not a local event. Measured on 2026-09-20 on that
CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, stopping the node carrying
the primary produced a new primary 70 seconds later in one run and 72 seconds in
another, on a cluster with `failoverDelay` 0.

The components of that window were not measured here. `failoverDelay` was 0, so
none of it is a delay requested from the operator. The rest is some mix of
Kubernetes deciding the node is gone and the operator promoting a replica, and
this bench recorded only the total. If that window is too slow, instrument when
the node went `NotReady`, because promotion has to fit inside whatever time
remains.

The operator advises against the planned version of this.

> "In order to avoid any data loss in the Postgres cluster, which impacts the
> database RPO, don't delete the Pod where the primary instance is running. In
> this case, perform a switchover to another instance first."
> ([CloudNativePG 1.30, instance manager](https://cloudnative-pg.io/docs/1.30/instance_manager/), read on 2026-09-20)

### How much did it actually lose?

Nothing, in the run designed to catch it, for a reason that matters more than
the result. Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d
cluster, a client committing one row per transaction at about 25 a second, and
appending each acknowledged id to a file outside the primary's node, recorded
656 acknowledged inserts. After the node was stopped and a replica was promoted,
the new primary held all 656.

That result is a lag measurement, not a guarantee. Under the bulk
load on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d
cluster, `pg_stat_replication` on the primary
showed both replicas with a replay lag of about 0.68 seconds while
`sent_lsn` ran ahead of `replay_lsn`. Asynchronous replication exposes that
window: commits acknowledged to the client but not yet present on whichever
replica gets promoted. A slow writer with sub-second lag loses nothing; a fast
writer with seconds of lag can lose the difference.

With asynchronous replication, a failover can lose acknowledged commits that
are not on the promotion candidate. The size of that window is the replication
lag at the moment of failure, not a property of node death. A node death does
not destroy the old primary's data either: it survives on its volume, which is
why rewind is possible, but anything not on the promoted timeline is discarded
from the cluster's history.

Synchronous replication closes that window at the cost of commit latency and
availability when a required standby is missing. Choose it against a stated
recovery point objective and pair it with a failover policy that will not
promote a candidate missing synchronously committed data, rather than enabling
it because writes feel important.

## `Running` and `Ready` are not "caught up"

Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, while a rejoining
replica was catching up:

| signal | value |
|---|---|
| `kubectl get pod` | `1/1 Running` |
| the pod's ready condition | `true` |
| `pg_controldata` cluster state | `in archive recovery` |
| rows in `pg_stat_wal_receiver` on that replica | 0 |
| rows in `pg_stat_replication` on the primary | 0 |
| the `Cluster` status | `Waiting for the instances to become active` |

The pod was Ready and the replica was not streaming from anywhere. That is the
configured behaviour rather than a bug. Read on 2026-09-20 from that cluster,
the pod's readiness probe is an HTTPS `GET /readyz` on port 8000, which is the
instance manager rather than PostgreSQL, and the `Cluster` sets no readiness
strategy. What the instance manager does behind that endpoint by default is
stated by the operator.

> "By default, the readiness probe uses `pg_isready`."
> ([CloudNativePG 1.30, instance manager](https://cloudnative-pg.io/docs/1.30/instance_manager/), read on 2026-09-20)

`pg_isready` answers whether the server accepts connections, not whether
replication is current. If "ready" is supposed to mean streaming, the operator
has a strategy for that and it must be configured.

> "streaming: marks the probe as successful when the replica begins streaming
> from its source and meets the specified lag requirements."
> ([CloudNativePG 1.30, instance manager](https://cloudnative-pg.io/docs/1.30/instance_manager/), read on 2026-09-20)

A lag bound can also be enforced for the life of the pod rather than only at
startup.

> "Unlike the startup probe, the `.spec.probes.readiness.maximumLag` option is
> continuously monitored."
> ([CloudNativePG 1.30, instance manager](https://cloudnative-pg.io/docs/1.30/instance_manager/), read on 2026-09-20)

`pg_is_in_recovery()` has the same limit in the other direction, and its
definition is one line.

> "Returns true if recovery is still in progress."
> ([PostgreSQL 18, System Information Functions](https://www.postgresql.org/docs/18/functions-admin.html), read on 2026-09-20)

That is all it claims. It says nothing about whether the server is streaming,
caught up, promotable, in the Service endpoints, or taking traffic, so a `true`
answers one question and is often read as answering five.

## A runbook that answers the right questions

After any disruption, use this order.

**Which member is primary, and did that change?**

```
kubectl get cluster app-db -o jsonpath='{.status.currentPrimary} {.status.targetPrimary}'
```

**Was the shutdown clean?** Ask the control file only while the instance is
still down. It also reads on a running server, but then it reports the live
state, so a pod that has already restarted answers `in production` whatever
happened:

```
kubectl exec app-db-1 -c postgres -- pg_controldata /var/lib/postgresql/data/pgdata | head -8
```

**Did it run crash recovery, and how long did replay take?** The two lines that
answer it are `database system was not properly shut down; automatic recovery in progress` and the `redo done ... elapsed:` line in the instance log.

**Did a rewind happen, and how big was it?** Look for `pg_rewind: need to copy`
against `pg_rewind: no rewind required` in the same log, and note whether it
read from the live primary or from an archive.

**Is it streaming, and how far behind?** On the standby and on the primary:

<!-- sql-check: postgres -->
```sql
SELECT status, sender_host, latest_end_lsn, last_msg_receipt_time
FROM pg_stat_wal_receiver;
```

<!-- sql-check: postgres -->
```sql
SELECT application_name, state, sync_state, sent_lsn, replay_lsn,
       replay_lsn IS DISTINCT FROM sent_lsn AS behind,
       replay_lag
FROM pg_stat_replication;
```

**Is it actually in service?** Check the Service endpoints, not the pod phase.
A pod can be `Running` and Ready and still be a replica that should not receive
write traffic.

Do not read `RESTARTS: 0` as "nothing happened". Measured on 2026-09-20 on that
CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, killing the postmaster in
place moved `RESTARTS` to 1, while deleting the pod produced a new pod, with a
new UID, whose restart count started at 0. A replacement pod is a new object,
not the old one rescheduled.

## How do I stop it coming back?

You cannot stop nodes dying. You can decide in advance what each failure costs.

Never force-delete a database pod to make it move. Use a switchover for
planned work on a primary, and an ordinary deletion with a real grace period
otherwise. The evidence above is that `--force --grace-period=0` removes the
part of the sequence that makes the shutdown clean.

Checkpoint often enough that replay is short, and measure the trade. Shorter
intervals reduce worst-case replay. They also mean more checkpoint work and,
with `full_page_writes` on, more full-page images in WAL.

> "When this parameter is on, the PostgreSQL server writes the entire content of
> each disk page to WAL during the first modification of that page after a
> checkpoint."
> ([PostgreSQL 18, Write Ahead Log](https://www.postgresql.org/docs/18/runtime-config-wal.html), read on 2026-09-20)

That is a throughput, WAL-volume and recovery-time trade to benchmark, not a
setting to lower on principle.

Confirm the rewind prerequisites before you need them, and configure WAL
archiving so a rejoining member can get the WAL it is missing from the archive
rather than from the instance currently serving your application.

Set your recovery point objective before choosing a replication mode. If
acknowledged commits must survive a node loss, that is synchronous replication
plus a quorum-aware failover policy, and the cost is commit latency. If seconds
of exposure are acceptable, monitor replay lag, because that lag is the exposure.

## How DBGorilla helps

DBGorilla connects read-only and samples the instance continuously, so the
restart shows up as what it did to your workload rather than as a line in a pod
log: the connection counts before and after, which sessions were active when the
instance went away, and the metric time series either side of the gap. All of
that was verified in a live session.
[Get started free →](https://app.dbgorilla.com/signup)

## Related

- [How to prove CloudNativePG failover works for your application](https://www.dbgorilla.com/learn/postgres/how-to-prove-cloudnativepg-failover-works-for-your-application/)
- [Should WAL have its own PVC on CloudNativePG?](https://www.dbgorilla.com/learn/postgres/should-wal-have-its-own-pvc-on-cloudnativepg/)
- [How to handle database migrations safely](https://www.dbgorilla.com/learn/postgres/how-to-handle-database-migrations-safely/)