What Is a Changelog? Format, Template, and How to Write One

Shayan, FounderUpdated 20 min read

A ship's officer with a moustache writing in a large open logbook at a wooden desk, an oil lamp beside him, while a cabin boy reads a sheet of paper by the open door under a porthole showing the sea.

A changelog is a running list of the notable changes made to a piece of software, ordered from newest to oldest, with a date or version number on every entry.

Most changelogs get written at 4:45 PM on a Friday right before someone cuts a release or shuts their laptop. On an open-source repo, someone says, "We'll just generate it from the commit messages," runs a script over git log, and publishes a file where developers upgrading a dependency have to dig past lines like this top entry from ESLint's CHANGELOG.md:

[0e2ab70] ci: disable eslint-plugin-unicorn ecosystem test (#21462) (Francesco Trotta)

On a SaaS team, the failure mode goes the other way. The team launches a /changelog page with plans to post every week. Then a sprint runs long, a week consists mostly of bug fixes and small UI tweaks, and someone in Slack says, "We didn't really ship anything big enough for a changelog post this week, let's wait until the new dashboard is ready." Three months pass, and a prospective customer clicking "Changelog" in the footer to see if the product is actively maintained finds a page frozen in last summer.

Below is how developer CHANGELOG.md files and SaaS product changelogs work in practice, two templates you can copy straight into your repo or changelog tool, and what separates the changelogs people actually read from the ones that go stale.

What is a changelog?

When the GNU project wrote its coding standards in the early days of open source, a changelog was a debugging log written for the next programmer who had to track down a regression. The GNU Coding Standards tell maintainers to "keep a change log to describe all the changes made to program source files," explaining that the goal is "so that people investigating bugs in the future will know about the changes that might have introduced the bug." For changes that users actually cared about, GNU kept a second file called NEWS with "a list of user-visible changes worth mentioning."

Over time, the word changelog migrated from the programmer's file-by-file log to the user-facing list. Today, the definition almost every developer knows comes from Olivier Lacan's Keep a Changelog convention, which released version 2.0.0 in June 2026:

A changelog is a curated, chronologically ordered list of the notable changes for each version of a project.

The word doing all the work in that sentence is curated. Wikipedia notes that a changelog can be either a curated record or "a generated report that includes all changes without regard to the ease of consuming or understanding." Both exist in the wild, and the uncurated kind is why so many repository changelogs are a chore to read. Keep a Changelog 2.0.0 is blunt about the difference: "a raw commit history is not a changelog."

On SaaS websites, teams skip the formal definitions and define the page by what sits on it. Buttondown calls its changelog "A day-by-day log of everything we ship." Zapier describes theirs as "New features, improvements, and changes to Zapier, newest first." Plausible tells visitors: "Plausible is updated multiple times per week. Here we list the major new features and improvements."

Whether it lives in a Markdown file next to your source code or on a /changelog page on your website, a real changelog does the same job. It is written by a person for the people who use the software, it leaves out internal noise they would never notice, and it puts the newest changes at the top with a date on every entry.

Changelog vs. release notes

Most teams use "changelog" and "release notes" as synonyms. Laravel's repository file is named CHANGELOG.md and opens with the heading # Release Notes for 13.x, while Intercom's page title is Intercom Changelog & Release Notes | Product Updates.

When a project does keep the two separate, the changelog is the complete running history across every version, and the release notes are the highlight announcement written for one specific release. As Keep a Changelog 2.0.0 puts it:

A changelog is the complete, ongoing record: every notable change, across every version, kept in one file in the repository and written plainly for anyone. Release notes are an announcement for a single release: a curated selection of its headline changes, often with upgrade steps and a marketing voice, published when that version ships. The changelog is the source; release notes are drawn from it and shaped for the announcement.

You can see this split on Go's website, which publishes a dedicated Release Notes page for each major version while noting on its release history page: "This page summarizes the changes between official stable releases of Go. The change log has the full details." Python works the same way, pairing its "What's New in Python" essays for major releases with a full changelog underneath that records every patch and bug fix.

The two kinds of changelog

Before you pick a format or a template, decide who is going to read it. A developer upgrading a library in package.json and a SaaS customer logging into a web app are looking for completely different things.

The developer changelog travels with the code. Most open-source projects keep it as a CHANGELOG.md file in the root of the repository, though Rust uses RELEASES.md, Deno uses Releases.md, pip uses NEWS.rst, and older projects like Go, Python, Django, PostgreSQL, and SQLite host theirs on their documentation websites. Its reader is an engineer upgrading from one version to another who wants to know three things before deploying: what broke, what is deprecated, and which pull request or issue has the back story if something starts failing in production.

The product changelog lives on the product's website for its customers, almost always at /changelog or /updates, even when the heading on the page says "What's new in Shopify" or "What's new in Plausible Analytics." None of the SaaS product taglines I looked at even mentions version numbers. Its reader is a customer who wants to see what they can do in the app today that they couldn't do last month, which plan includes the feature, and whether the idea they asked for on your feedback board has shipped.

If you build a developer platform or an API, you'll usually need both. Render and Paddle run public product changelogs for platform features while keeping a sidebar at the top of the page with the latest version numbers for their CLIs and SDKs. Sentry weaves SDK version numbers directly into its changelog entry titles whenever a library release adds a capability worth explaining.

The changelog format

Before getting into specific conventions, every useful changelog shares four ground rules:

  1. Newest first. A reader opening your changelog wants to see what changed this week, not scroll past five years of history to find the bottom of the file.
  2. A date on every entry. Version numbers mean nothing without a calendar date beside them. An engineer debugging an issue needs to know whether v3.9.10 shipped yesterday or last winter, and a SaaS buyer checks the dates to see if your team is still shipping.
  3. One clear line or headline per change, starting with what changed for the user. Tailwind writes: Support --watch --poll[=ms] in @tailwindcss/cli when filesystem events are unreliable or unavailable. Buttondown writes: Stopped asking you to confirm deleting a nearly empty draft. Both tell you what changed in the first five words.
  4. A consistent way to tell the kind of change apart, whether that's a section heading like Fixed, a badge like New, or the opening verb of the line.

Keep a Changelog

When developers talk about a standard CHANGELOG.md format, they almost always mean Keep a Changelog. It puts everything in one repository file with an Unreleased section at the top that collects changes before the next version is tagged. Below that sits one section per version, newest first, headed ## [1.2.0] - 2026-10-31 in ISO YYYY-MM-DD format, with changes grouped under six fixed headings: Added, Changed, Deprecated, Removed, Fixed, and Security. Each version heading links to the git diff between that release and the previous one, and pulled releases get marked [YANKED].

Version 2.0.0 of the convention settles the edge cases that used to trip maintainers up. It draws a clean line between Fixed and Changed:

Fixed: the behavior was wrong, and is now correct. Changed: the behavior worked as intended, and now works differently.

Instead of giving breaking changes a seventh heading, 2.0.0 puts a Breaking: prefix on the entry inside whichever of the six headings fits, and asks security entries to lead with their CVE identifier. It also gives a clear rule for dependency updates: "If it matters to your users, describe its effect under the right type. If it does not, leave it out."

What surprised me when I checked the repositories of three dozen major open-source projects is that almost everyone cites Keep a Changelog, and almost nobody follows all of it. Tailwind CSS was the only project in the entire group that followed the spec from top to bottom: the preamble, Unreleased, the standard group headings, ISO dates, a pull request link on every line, and compare links at the bottom of the file. Here is the top of Tailwind CSS's CHANGELOG.md, trimmed to two entries:

# Changelog
 
All notable changes to this project will be documented in this file.
 
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
## [Unreleased]
 
### Added
 
- Add `@tailwindcss/turbopack` package to run Tailwind CSS with Next.js ([20367](https://github.com/tailwindlabs/tailwindcss/pull/20367))
 
### Fixed
 
- Ensure watch mode detects changes to symlinked `@source` files whose real paths aren't otherwise scanned ([#20356](https://github.com/tailwindlabs/tailwindcss/pull/20356))
- Ensure custom variants using `@scope` wrap the generated utilities instead of nesting inside them ([#20369](https://github.com/tailwindlabs/tailwindcss/pull/20369))

A few other projects adopt pieces of it. Mastodon uses the group headings and copies Keep a Changelog's opening line, but leaves out Unreleased. Laravel, esbuild, and Terraform keep an Unreleased section at the top of the file without using the six standard headings. Most other projects organize entries around their own architecture, like Rust grouping by Language, Compiler, Libraries, and Cargo. Keep a Changelog is a great house style to adopt because every developer immediately knows how to scan it, just know that you are choosing a convention rather than following a universal law.

The GNU ChangeLog

The older convention still sits in the GNU Coding Standards. Each entry starts with a header line containing the date, the author's name, and their email address, followed by every changed file and function name marked with an asterisk:

2019-06-15  Paul Eggert  <eggert@cs.ucla.edu>
 
	Port to platforms where tputs is in libtinfow
	* configure.ac (tputs_library): Also try tinfow, ncursesw (Bug#33977).

Nobody writes changelogs this way anymore, and you shouldn't either. Even the GNU manual now notes that the header line is only needed when change logs aren't kept in a version control system. Git commit history and git blame took over the job of recording which function changed on Tuesday, leaving the changelog free to focus on what changed for the user.

How SaaS product pages format their changelogs

Step outside GitHub repositories onto SaaS product websites and Keep a Changelog's six headings vanish completely. Customers don't want to scan a raw bullet list under Deprecated and Removed. They want a short post with a clear headline, a date, a paragraph explaining what the update lets them do, a screenshot of the interface, and a link to the docs.

When SaaS teams label their entries by type, they stick to a short list of positive badges like New, Improved, Feature, or Beta. Even though every software team spends half its life fixing bugs, almost no SaaS changelog puts a Fixed badge on top-level entries. Render's changelog is the rare exception that includes Fixed, Deprecated, and Security alongside New and Improved, and even on Render, Fixed appears only 10 times against 148 entries labeled New or Improved. Instead of publishing standalone bug-fix posts, teams like Neon and Lemon Squeezy put a Fixes & improvements section at the bottom of a broader feature or weekly post.

Other products skip type labels altogether and tag posts by product area so customers can filter to the parts of the platform they use, the way Paddle tags entries with Transactions, Checkout, Paddle.js, and API.

If your team ships small polish and bug fixes every day and you don't want to write a multi-paragraph blog post for each one, Buttondown's changelog has a format worth stealing. It groups updates by calendar day, writes one sentence per change starting with a verb that tells you the type of change, and thanks the customer who reported the problem by name. Here is how its October 30, 2026 entry opens:

Stopped asking you to confirm deleting a nearly empty draft (thanks, Marcin!)

Fixed confirmed duplicate emails getting blocked when sent (thanks, Etienne!)

Fixed extra space around captioned images in emails (thanks, Davis and Sacha!)

That gives you the scannability of Keep a Changelog with the warmth of a product page, because the category heading is folded right into the first word of each line.

Changelog templates to copy

Here are two Markdown templates you can paste straight into your repository or your changelog tool.

CHANGELOG.md template for a repository

This follows Keep a Changelog 2.0.0. Keep the six headings in this order, and delete any heading that has no entries in a given release.

# Changelog
 
All notable changes to this project will be documented in this file.
 
The format is based on [Keep a Changelog](https://keepachangelog.com/en/2.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
## [Unreleased]
 
### Added
 
- New capability, described by what it lets the user do ([#123](https://github.com/org/repo/pull/123))
 
## [1.2.0] - 2026-10-31
 
One or two sentences on the theme of the release, if it has one. Optional.
 
### Added
 
- New capability, described by what it lets the user do ([#118](https://github.com/org/repo/pull/118))
 
### Changed
 
- **Breaking:** behavior that worked as intended and now works differently, with what to do about it or a link to the migration guide ([#115](https://github.com/org/repo/pull/115))
- Non-breaking change to existing behavior ([#116](https://github.com/org/repo/pull/116))
 
### Deprecated
 
- Feature that still works and will be removed in 2.0, with its replacement ([#110](https://github.com/org/repo/pull/110))
 
### Removed
 
- Feature removed in this version, deprecated since 1.0 ([#105](https://github.com/org/repo/pull/105))
 
### Fixed
 
- Behavior that was wrong and is now correct, described from the user's side ([#120](https://github.com/org/repo/pull/120))
 
### Security
 
- CVE-2026-00000: what was exploitable and in which versions, leading with the identifier ([#121](https://github.com/org/repo/pull/121))
 
## [1.1.0] - 2026-09-12
 
### Added
 
- ...
 
[Unreleased]: https://github.com/org/repo/compare/v1.2.0...HEAD
[1.2.0]: https://github.com/org/repo/compare/v1.1.0...v1.2.0
[1.1.0]: https://github.com/org/repo/compare/v1.0.0...v1.1.0

Those reference links at the bottom of the file turn every version heading into a clickable GitHub diff link. Linking each bullet to its pull request or issue is one of the most useful habits in a developer changelog, because any engineer who gets bitten by an edge case can click through to read the code and the discussion. If your project deploys continuously and doesn't use version numbers, Keep a Changelog 2.0.0 recommends keeping dated entries directly under Unreleased.

Product changelog entry template

This template combines the most helpful details from the SaaS changelogs I reviewed: Render's clean type badge, Zapier's What changed summary and plan availability line, Shopify's link to the help docs, and a link back to the customer request that inspired the feature.

## Title that says what the user can now do
 
**New**
 
October 31, 2026
 
One paragraph: what changed, in the reader's terms, and what it replaces or fixes.
If it needs a screenshot, put it right under this paragraph.
 
**What changed**
 
- First visible difference
- Second visible difference
 
**Availability:** every plan, or the specific plans that include it, plus where to turn it on if it is off by default.
 
[Read the docs →](https://example.com/docs/the-feature)
 
Built from [this request](https://feedback.example.com/p/the-request)

Stick to a small, predictable set of badges like New, Improved, Fixed, and Security so your tags don't drift over time. If you also need templates for major release announcements, security advisories, or App Store text, grab the six filled examples in our release notes template guide.

Real changelog examples worth copying

The best changelogs respect how little time the reader has. When someone opens your changelog, they are usually trying to answer a specific question in thirty seconds and get back to work.

For infrastructure and backend tools, that question is almost always "is this upgrade safe, or do I need to run a migration?" PostgreSQL's release 18.6 notes answer that before listing a single bug fix, opening with a Migration to Version 18.6 section that tells you immediately whether you need a dump and restore and which indexes need to be rebuilt. Django's release notes do the same for security patches. Instead of burying CVEs in a flat list, its 6.1.2 page opens with a plain-English severity count and gives each vulnerability its own section above the bug fixes:

Django 6.1.2 fixes one security issue with severity "low", three security issues with severity "moderate", and provides a fix for an insufficient security mitigation in 6.1.

When a project merges hundreds of commits between releases, a flat list is too long to scan, and a short summary alone hides details. Node.js's CHANGELOG_V26.md solves this by having the person cutting the release write a curated Notable Changes section at the top, followed by the complete generated commit list underneath. Its 26.13.0 entry opens with the exact lifecycle news an ops team needs:

This release marks the transition of Node.js 26.x into Long Term Support (LTS) with the codename 'Lithium'. It will continue to receive updates through to the end of April 2029.

For developer tools that parse, bundle, or lint code, showing a three-line code block beats a paragraph of explanation. In esbuild's CHANGELOG.md, maintainer Evan Wallace explains each bug in plain prose and includes a minimal code snippet showing the exact TypeScript or JavaScript syntax that used to fail. And Ruff's CHANGELOG.md groups entries around how developers actually adopt linter rules: Breaking changes, Stabilization, Preview features, Bug fixes, and Performance.

On SaaS product pages, customers often read about a new feature, switch over to the app, and can't find it because it's gated to Enterprise or hidden behind a setting. Zapier's changelog eliminates that guesswork by including a What changed list and an Availability line on every entry that names the exact plans, such as Free, Professional, Team, Enterprise.

Shopify's changelog keeps its main feed effortless to scan by pairing product-area tags like Admin, POS, and Checkout with a single-sentence summary on the index:

Manage variants directly on the product detail page instead of opening a separate page.

Every item on Shopify's index then clicks through to its own page with a direct link to the help center article.

In our changelog examples post, we sort entries into twelve kinds and show a real entry for each, quoted word for word from Linear, Supabase, Tailscale, Vercel, and others.

Where changelogs go wrong

Most bad changelogs fail in one of three ways, and you can spot all three across well-known products.

The first is dumping raw git history or build artifacts on the reader. ESLint's CHANGELOG.md is a 1.1-megabyte file of ungrouped commit messages with hashes, where bot commits like docs: Update README (GitHub Actions Bot) sit right between real bug fixes. Kubernetes's CHANGELOG-1.37.md forces readers to scroll past roughly sixty lines of binary and container image download tables before reaching the first change, and because an automated script pulls entries by label without a human edit pass, version 1.37.2 lists the exact same Go upgrade twice under different headings: once as Kubernetes is now built with Go 1.26.10 under Dependency and again as Kubernetes is now built using Go 1.26.10 under Feature.

The second trap is hiding the current release or leaving out dates. When a developer opens CHANGELOG.md on your repository's default branch, they expect to find the version they have installed. On Terraform's main branch, CHANGELOG.md contains only 1.18.0 (Unreleased) and some experiments, while the notes for the released 1.17.1 live on a separate v1.17 branch. Even hand-written files fall behind when updating them isn't part of the release script: React's CHANGELOG.md sat at 19.3.0 more than two weeks after 19.3.1 shipped on GitHub Releases, and several popular libraries omit release dates inside their CHANGELOG.md files altogether.

The third trap is letting a SaaS changelog go stale or turning it into a quarterly marketing brochure. On Lemon Squeezy's /changelog in late October 2026, the newest entry was from August 2025, and several posts had an empty Fixes & Improvements heading with nothing underneath. Asana goes to the other extreme on its /whats-new page, replacing a dated chronological log with a seasonal campaign page headed Explore The Quarterly Release: Q3 2026, with no calendar dates, no bug fixes, and no history of prior releases.

Can you auto-generate a changelog?

Every engineering team eventually asks why anyone writes changelogs by hand when Git already has every commit and pull request. About half of open-source projects generate their changelogs with a tool, and whether the output is readable or a mess like ESLint's comes down to what the tool uses as its input.

Some projects build their changelog directly from commit messages or pull request titles, using tools like conventional-changelog or git-cliff. This only works when every maintainer writes commit subjects and PR titles for end users. Vue and Vite pull it off because a commit subject like compat: expose _setupProxy for Vue 2.7 compiled script setup is written to be read in a changelog. If your team's commit history is full of fix lint and address review comments, a commit generator will publish that noise straight to your users.

A better approach for larger teams is generating the file from short fragments that a human writes when opening a pull request. Svelte and Astro use changesets, Python uses blurb, and Prettier drops one Markdown file per PR into a changelog_unreleased folder. Here, the tool is just an assembler. It avoids merge conflicts on CHANGELOG.md, while the sentence the user reads was still written by the engineer who built the change at the moment they understood it best.

You can also combine a generator with a human editor, the way Node.js writes a hand-curated Notable Changes section above a generated commit list, or the way curl's maintainer runs a script over recent commits and then edits the output by hand.

What about having a language model write the changelog? Keep a Changelog 2.0.0 warns that "it is now easy to publish a fluent changelog that no one has read," and offers a set of instructions worth copying straight into your prompt:

summarize notable, user-facing changes; do not paste a git log; sort each change into one of the six types; explain the reason in the text; mark breaking changes; and remove anything not worth reading. Then read the result before anyone else does.

How to write a changelog entry people actually read

Whether you are adding a bullet to CHANGELOG.md or writing a post for your SaaS updates page, a good entry answers the reader's silent question: "What does this change for me?"

Start the sentence with the change as the user experiences it, not the internal code you refactored. When Tailwind fixed a noisy compiler warning for Angular developers, the team didn't describe the AST change; they wrote: Don't warn about Angular's ::ng-deep and :host-context() when optimizing CSS. When Intercom redesigned how tickets open in its customer portal, the entry opened with what the user sees on screen:

Your customers' support portal now works more like a real inbox. Conversations and tickets open on their own full-page, shareable screens instead of a floating widget, with ticket details alongside.

Notice that second sentence: instead of a floating widget. Saying what the product did previously makes the new behavior click immediately, even for a reader who hasn't touched that screen in months.

Keep a Changelog 2.0.0 notes that "keeping a changelog is partly an act of restraint." If a refactor, test suite change, or internal migration doesn't change anything a user can see, leave it out. And when a change does require the reader to update an API call or flip a setting, put that instruction right in the entry and link to the docs. For more side-by-side rewrites of real updates, see our guide on writing changelogs people read.

Where your changelog should live

For a developer library or CLI, put CHANGELOG.md in the root of your repository and copy each release's notes into GitHub Releases. Keep a Changelog cautions against publishing your changelog only on GitHub Releases, as Next.js and Prisma do, because "these releases don't travel with the repository and follow you to another host." Keeping the Markdown file in the repository also means developers and coding agents can search it locally inside their editor.

For a SaaS product, host your public changelog at /changelog or /updates, link it in your navigation or footer, and give each entry its own permanent URL so your team can paste a direct link into a support reply or sales email. Including an RSS or Atom feed, as Shopify, Ghost, Render, and Clerk do, gives power users and community Slack channels an easy way to subscribe.

Just remember that most of your active customers don't visit your marketing site every week to check /changelog. They log straight into your app to do their jobs. Putting an updates feed inside your product with an in-app widget reaches the people who actually use the features you ship.

Draft your changelog from the requests you shipped.

Juno, the assistant in UserJot's changelog editor, lists the requests you completed since your last post, reads their descriptions and comments, and writes a highlighted draft with the title, tags, and linked requests filled in. Free to start.

Try UserJot free

From the customer request to the changelog

The reason SaaS changelogs fall behind is that sitting down on Friday afternoon to reconstruct what shipped from Linear tickets and Slack threads feels like homework. When your feedback board, public roadmap, and changelog live in the same tool, the customer requests you completed that week are already your outline.

On UserJot, marking a request Completed moves it to the Done column on your roadmap and automatically emails everyone who posted, voted, or commented on it. When you open the changelog editor to write the public post, Juno, our editor assistant, lists the requests you completed since your last update, reads their descriptions and comment threads, and writes a highlighted draft with the title, tags, and linked requests filled in for you to review.

Once you publish, the post goes live at /updates on your board with its own URL and the original customer requests linked underneath, and the in-app widget can show an unread count or expand with the post title so signed-in users see what's new without leaving your app. Changelog publishing is included on every plan, including Free, and you can read more about the workflow in Publish updates.

The UserJot changelog editor: a product update about a mobile app, with Juno drafting its opening from the requests that shipped.

Frequently asked questions

What is a CHANGELOG.md file?

A CHANGELOG.md file is a Markdown document kept in the root of a repository that lists the notable changes in each released version of a project, ordered from newest to oldest. Most open-source libraries use that exact filename as recommended by Keep a Changelog, though some projects name the file RELEASES.md like Rust or NEWS.rst like pip.

What is the difference between a changelog and release notes?

A changelog is the complete, running history of every notable change across the life of a project, while release notes are the announcement and upgrade guide for a single release. Projects like Go and Python publish a readable "What's New" or release notes summary for each major version and link to the full changelog underneath for every patch. On most SaaS websites, the two terms name the exact same /changelog page.

What is the standard changelog format?

There is no official standard, though Olivier Lacan's Keep a Changelog convention is the closest thing for code repositories. It puts an Unreleased section at the top, followed by one section per version with an ISO date like ## [1.2.0] - 2026-10-31, and groups entries under Added, Changed, Deprecated, Removed, Fixed, and Security. SaaS product changelogs skip those six headings in favor of short dated posts with screenshots and badges like New or Improved.

Should a changelog be newest first?

Yes, a changelog should always put the most recent release or update at the top. Readers opening your changelog are almost always checking what changed since they last looked or whether a specific fix has shipped yet. Making them scroll past years of older entries to find this week's release defeats the purpose of the file.

Does a changelog need version numbers?

Only if your users install or upgrade your software by version. Libraries, CLIs, mobile apps, and databases like Tailwind CSS, Rust, and PostgreSQL organize their changelogs by version number and date. SaaS web apps that deploy continuously, like Shopify, Zapier, and Buttondown, skip version numbers and date each entry instead.

Is a git log a changelog?

No, a git commit log is a step-by-step record of changes to the source code, written for engineers working inside the repository. It includes merge commits, test tweaks, bot updates, and partial commits that mean nothing to an end user. A changelog summarizes only the notable, user-visible differences in plain language.

What does Unreleased mean in a changelog?

Unreleased is a section at the top of a CHANGELOG.md file where maintainers log notable changes that have been merged into the main branch but haven't been cut into a numbered release yet. At release time, the Unreleased heading is renamed to the new version number and date, and a fresh Unreleased section is started above it. Projects that deploy continuously without version numbers can also keep dated entries under Unreleased.

How often should a changelog be updated?

Update a developer changelog every time you cut a release, and update a SaaS product changelog whenever you ship a change users can see. Some teams like Buttondown add one-line entries almost every day, while others like Railway and Neon publish a single roundup page each week. What matters is keeping the rhythm steady, because a changelog whose newest post is a year old makes an active product look abandoned.