
An Agile project charter is a short, shared agreement that explains why an initiative exists, what outcome it should produce, which boundaries and constraints apply, who decides what, and how the team and stakeholders will work together. Unlike a traditional charter, it fixes the outcome and guardrails and leaves the detailed solution open, so the team can learn and adjust through iterations.
This guide gives you a one-page Agile charter template, a completed example, and a facilitation plan for writing it with your team. It also covers how the charter relates to the product goal, team charter, and backlog, and how to keep a charter in Confluence, AFFiNE, or another shared workspace. If you need a general-purpose charter for a traditional or fixed-scope project, use our free project charter template instead.
At a glance
- Length: one page. Agile Alliance recommends that a charter fit on a single sheet (Agile Alliance).
- Written by: the product owner and team, with the sponsor. It is a working session, not a document one person fills in.
- Approved by: the executive sponsor, who confirms the vision, funding, and guardrails.
- Updated when: the vision, success measures, funding, or authority change. Feature-level change belongs in the backlog.
Copy this into a shared page and replace the bracketed prompts. Keep each answer to a sentence or a few bullets. If you cannot fill a field, write the question, an owner, and a date instead of guessing.
Initiative: [Name] · Charter version / date: [v1.0 — date]
Vision (why): [One or two sentences on the problem and who benefits]
Outcome and success measures: [What will be different, with 2–4 measures: baseline → target, by when]
Guardrails:
- Fixed: [Budget ceiling, deadline, compliance or platform constraints that will not move]
- Flexible: [What the team may change based on feedback: features, sequencing, design]
Scope boundaries: In: [areas, users, channels] · Out: [plausible adjacent work that is not included]
Stakeholders and decision rights:
- Sponsor: [Approves charter, funding, and changes to guardrails]
- Product owner: [Owns backlog order and outcome trade-offs]
- Team: [Owns how the work is built and estimated]
- Others: [Security, legal, operations, customers — what each approves or is consulted on]
First release target: [The smallest release that tests the outcome, and a target window]
Working agreements: [Iteration length; review and demo cadence; where decisions and documents live; definition of done owner]
Top risks and assumptions to test: [If… then… — owner — how and when we will test it]
Review points: [When the sponsor and team will check progress against the outcome and decide to persevere, pivot, or stop]
Approval: [Sponsor name] — [approved / approved with conditions] — [date]
The Word and PDF charter templates on our general charter guide also work for Agile teams. Delete the fields you do not need and add the guardrails and working agreements above.
The one-page Agile charter as a canvas. Fixed guardrails sit next to what the team may change, so trade-offs are visible.
Many Agile frameworks do not require a charter document, and Agile Alliance warns against filling in a template mechanically: the value is mostly in the conversation that produces the charter (Agile Alliance). Still, most organizations need something that does three jobs:
The California Department of Technology describes the Agile charter as concise, understandable, and collaborative: "just enough information to provide appropriate decision making," with legal and procedural detail moved to other documents, and approval by the executive sponsor once drafted (California Department of Technology).
| Aspect | Traditional charter | Agile charter |
|---|---|---|
| What is fixed at approval | Deliverables and high-level scope, with a schedule and budget | The outcome, success measures, and guardrails (budget, deadline, constraints) |
| What can change without reapproval | Little; changes usually go through change control | Features, priorities, and sequencing, as long as guardrails hold |
| Who writes it | Project manager, approved by the sponsor | Product owner and team together, approved by the sponsor |
| Typical length | One to several pages | One page or one wall |
| How success is judged | Delivered on scope, time, and budget | Moved the outcome measures within the guardrails |
| How it is used afterward | Baseline for scope control | Reference point at reviews to persevere, pivot, or stop |
Both versions should still name the sponsor, the decision rights, the boundaries, and the approval. The main difference is what you commit to: a solution or an outcome.
Traditional charters fix the solution early. Agile charters fix the outcome and guardrails and let the solution evolve.
Agile charters work best when they are written together. A kickoff session is a natural place to do it: the California guidance suggests starting chartering with a collaborative kickoff that covers vision, success criteria, stakeholders, risks, responsibilities, size, and roadmap. Our project kickoff meeting agenda can host a shorter version of this workshop.
The product owner drafts the vision sentence, two or three candidate success measures, and the known constraints. The sponsor confirms the budget ceiling and any fixed dates. Invite the team, the sponsor, and the two or three stakeholders whose approval or cooperation the initiative depends on.
Read the draft vision and ask each person to rewrite it in their own words on a sticky note. Differences in wording expose differences in understanding. Agree one version, then pick 2–4 success measures, each with a baseline (or a task to get one), a target, and a date.
Split constraints into fixed and flexible. Then list what is in and out of scope at the level of users, channels, or product areas, not features. Out-of-scope items should be things someone could reasonably assume are included.
For each type of decision (backlog order, release go/no-go, budget change, security approval) agree who decides, who is consulted, and who is informed. A RACI matrix works if you keep it to a handful of decisions.
Ask, "What must be true for this outcome to be reachable within the guardrails?" Write each answer as an assumption with a way to test it early, for example in the first release or a short spike. Assign an owner.
Agree iteration length, review and demo cadence, where documents and decisions live, and who owns the definition of done. Set the first review point where the sponsor and team will look at the measures and decide to persevere, pivot, or stop. The sponsor then approves the charter, with any conditions recorded.
A 90-minute chartering workshop. Most of the time goes to vision, outcome, and guardrails, because those are what the team will refer back to.
This fictional example shows the level of detail a one-page Agile charter needs. The numbers are illustrative, not benchmarks.
Initiative: Guided onboarding for new workspaces · Version: v1.0
Vision: New workspace owners often reach an empty screen without knowing the first useful step. We want them to reach their first useful outcome in their first session.
Outcome and success measures: Seven-day activation rises from 38% to at least 45% within 30 days of full release. Median time to first completed workspace falls from 14 minutes to 9 or less. Onboarding-related support tickets per 1,000 new workspaces fall by 15%.
Guardrails: Fixed: up to $85,000 internal budget; web app only; no changes to billing or the permissions model; first release within 8 weeks. Flexible: checklist content, sample workspace design, sequencing of import options.
Scope boundaries: In: web sign-up flow, onboarding checklist, sample workspace, CSV import entry point, event tracking. Out: native mobile apps, localization, lifecycle email, enterprise provisioning.
Decision rights: Sponsor (VP Product) approves guardrail changes and full release. Product owner orders the backlog and makes outcome trade-offs. Engineering lead owns technical approach and rollback. Security and Accessibility approve their release criteria.
First release target: Checklist and sample workspace to 10% of new sign-ups by Week 5.
Working agreements: Two-week iterations; demo to stakeholders at the end of each; decisions recorded on the charter page; definition of done owned by the team and reviewed each retro.
Assumptions to test: The current activation event reflects real early value (Data validates in iteration 1). The feature-flag service supports percentage rollout (Engineering spike in week 1).
Review points: After the 10% release and 30 days after full release: persevere, adjust, or stop.
Approval: VP Product — approved — [date].
Compare this with the traditional charter example for a self-hosted knowledge base rollout. The traditional version lists deliverables and milestones in more detail. The Agile version commits to measures and guardrails and leaves the feature list to the backlog.
An Agile project charter does not replace the product goal, roadmap, backlog, or team charter. It sits above them and explains why they exist.
| Artifact | Answers | Changes how often |
|---|---|---|
| Agile project charter | Why this initiative, what outcome, within which guardrails, who decides | Rarely; only when vision, measures, funding, or authority change |
| Team charter | How this team works together: values, norms, communication | When the team or its ways of working change |
| Product goal and roadmap | What the product is aiming for over the next quarters | Quarterly or as strategy shifts |
| Product backlog and user stories | What to build next, in what order | Continuously |
| Sprint plan and definition of done | What this iteration delivers and what "done" means | Every iteration |
A common mistake is to load the charter with backlog items or a sprint-by-sprint plan. If a line in the charter would change every two weeks, it belongs in a lower artifact. If stakeholders only need a quick summary rather than an approved charter, a project one-pager is lighter. For the other documents produced while planning, see our list of project planning phase deliverables.
Use this before asking the sponsor to approve.
Teams often ask where the charter should live. It is short, so the tool matters less than three habits: keep it in one place everyone can find, link it from the backlog and review notes, and record version and approval on the page itself.
When delivery is under way, decide how to track project progress against the measures in the charter, not only against the backlog.
An Agile project charter is a short, collaboratively written agreement that states an initiative's vision, outcome measures, guardrails, scope boundaries, decision rights, working agreements, and review points. It fixes the outcome and constraints rather than the detailed solution.
The product owner and team usually write it together in a workshop with the sponsor and key stakeholders. The executive sponsor approves it, because the sponsor controls funding and the guardrails.
One page. Agile Alliance recommends that a charter fit on a single sheet so the team actually refers to it. Move procedural and legal detail into other documents.
The project charter explains why the initiative exists, what outcome it should achieve, and within which guardrails. A team charter describes how a team works together, such as values, norms, and communication. A team can keep one team charter across several project charters.
At the start of an initiative, after the idea has a sponsor and before the first iteration. A collaborative kickoff meeting is a good place to draft it.
Yes. Update it and get sponsor approval again when the vision, success measures, funding, guardrails, or decision rights change. Feature and priority changes belong in the backlog and do not need a new charter.
How this guide was prepared: This article was first published in August 2023, revised in August 2026, and refocused on Agile chartering in October 2026, when general charter guidance moved to our project charter template guide. The template, workshop timings, and checklist are AFFiNE editorial recommendations based on the sources above. They are not results of a controlled study. The example is fictional. AI tools assisted with drafting, and the content was reviewed and edited by the AFFiNE team.