In PowerShell, `Get-Process | Format-Table Name, CPU | Export-Csv procs.csv` writes a CSV of formatting metadata instead of process data. Why are the `Format-*` cmdlets the end of a pipeline?

## What Format-* actually emits The mental model most people carry is that `Format-Table Name, CPU` gives you "the same objects, with fewer columns." It does not. `Format-Table` is a rendering engine front end. It consumes your objects and emits a *different* stream: a sequence of internal formatting-instruction objects describing a table — where it starts, what its columns are, one entry per row, where it ends. Their types live in the `Microsoft.PowerShell.Commands.Internal.Format` namespace, and they exist to be interpreted by an output cmdlet. You can see the substitution directly: ```powershell Get-Process | Get-Member # System.Diagnostics.Process Get-Process | Format-Table Name, CPU | Get-Member # Format-namespace types instead ``` That second line is the whole answer to the question. By the time the pipeline reaches `Export-Csv`, there is no process object left to serialise. ## Why Export-Csv produces nonsense `Export-Csv` is a faithful serialiser: it takes each object, enumerates its properties, and writes them as columns. Fed formatting-instruction objects, it does exactly that — it writes *their* internal members as the header row and their values as data. The result is a valid CSV of something you never wanted, with no `Name` or `CPU` column and usually a row count that does not match your process count, because table start, group start and table end are objects too. Nothing errors; you just get garbage, which is why this bites people in scripts that appear to work. The same applies to `ConvertTo-Json`, `Export-Clixml`, `Where-Object`, `Sort-Object` and `Select-Object`: put any of them after a `Format-*` cmdlet and they operate on display instructions. ## The rule > A `Format-*` cmdlet may be followed only by an `Out-*` cmdlet, and by nothing that treats the stream as data. `Out-Host` (the implicit destination of anything falling off the end of a pipeline), `Out-File` and `Out-String` all understand formatting instructions and turn them into text. That pairing is legitimate: ```powershell Get-Process | Format-Table Name, CPU -AutoSize | Out-File .\procs.txt ``` That file contains a human-readable table — the same thing you would see on screen, including column padding and truncation. It is fine for a report a person reads and useless as an input to another program. ## Select-Object is the data-shaping cmdlet The fix is to separate two jobs that look similar: - **Choosing which properties you care about** is `Select-Object`. It emits real objects (with the chosen properties) that downstream cmdlets can still filter, sort and serialise. - **Deciding how those properties are painted on a screen** is `Format-*`, and it is the last thing that happens. ```powershell # Data out to a file Get-Process | Select-Object Name, Id, CPU | Export-Csv .\procs.csv -NoTypeInformation # Same data, rendered for a human, last Get-Process | Select-Object Name, Id, CPU | Sort-Object CPU -Descending | Format-Table -AutoSize ``` Note the ordering in the second line: every stage that reasons about values comes first, and formatting is appended at the very end. ## The related surprise: implicit formatting Even when you never type a `Format-*` cmdlet, one runs. Objects that fall off the end of a pipeline go to the default output path, which consults the type's registered formatting data to decide the layout — which is why `Get-Process` shows a handful of columns out of dozens of properties, and why an object with more than four properties tends to render as a list rather than a table. The console view is a *view*. `Get-Member`, `Select-Object *` and `Format-List *` are how you see past it. This also explains a related trap: `Get-Process | Out-File procs.txt` writes the rendered table, not the data, for exactly the same reason — `Out-File` sits at the end of the output path and receives formatted text. ## What to say in an interview Name the mechanism (format cmdlets substitute display-instruction objects for your data), name the rule (`Format-*` last, only `Out-*` after it), and name the correct alternative (`Select-Object` to shape data, `Export-Csv`/`ConvertTo-Json` to serialise it). Mentioning that the console table is itself produced by that same formatting layer shows you understand it is not an edge case but the normal end of every pipeline.