Our RFCs always record the decision but never why we rejected the alternatives. Does Projan fix that?

That's the gap it's built for. Because Projan facilitates the discussion, it has the rejected options and the reasons they lost — and it writes an 'Alternatives considered' section into the page, not just the winning approach. The thinking survives, which is the part that usually doesn't.

Can Projan raise the Jira tickets for an architecture decision, or only write the page?

The Confluence page is the only thing Projan writes into Confluence — it doesn't create issues there, because Confluence has none. But the same session can push the implementation work to Jira or Linear as proper tickets. One conversation, a page in Confluence and tickets in your tracker.

Can Projan read an existing Confluence page so the RFC builds on prior decisions?

Yes. Paste a Confluence page URL or ID into a session and Projan pulls it in as context. If last quarter's queueing decision constrains this one, that constraint is in the room instead of being rediscovered halfway through.

Who actually authored the page — is it Projan's words or the team's decision?

The decision is the team's; Projan facilitates it and writes it up. It isn't ghostwriting an opinion — it's recording the approach the team landed on, in the structure of an RFC, with the reasoning the discussion produced. You review the page before it's created in Confluence.

We're an engineering team that argues decisions in Slack threads. Do we have to move to plan with Projan?

No. Projan's Slack and Microsoft Teams bots run the discussion in the channel you already argue in. The web workspace is there if you'd rather. Wherever the decision happens, the agreed page lands in Confluence — you don't relocate the team to get the document.

Will Projan overwrite the architecture page we already maintain?

No. It creates a new page for you to review; it doesn't edit or replace pages already in your space. If the new RFC supersedes an old one, linking or archiving the old page is your call to make in Confluence.

Does this replace Confluence as our system of record?

No. Confluence stays the record. Projan runs the decision and writes the result into Confluence so the page reflects what the team agreed and why — rather than a conclusion one person typed up that the rest merely tolerated.

We write everything down in Confluence — can Projan produce the page our team actually agreed on, not just a draft?

Confluence is full of pages that record a conclusion but not the thinking — and pages one person wrote that everyone else merely tolerated. Projan changes how the page gets made. It facilitates the decision itself, captures the options weighed and the reasoning as the team works through them, and writes the result into Confluence as a structured page: the agreed approach, the alternatives considered, what's out of scope. If that decision also needs tickets, the same session sends them to Jira or Linear. Confluence gets the durable narrative your team actually agreed on, not a draft someone abandoned.

Six months after an architecture decision, someone opens the Confluence page to find out why you chose Kafka over a managed queue — and the page says, in effect, “we chose Kafka.” Not what else was on the table. Not the throughput numbers that tipped it. Not the operational cost someone raised and the team decided to swallow. The conclusion is there in tidy headings; the argument that produced it is gone. Worse are the pages that read like one engineer’s manifesto, written solo and nodded at in a meeting nobody quite remembers agreeing in.

The page nobody actually agreed on

A Confluence page is a snapshot of an outcome. The decision that produced it happened earlier and elsewhere — in a thread, a call, a heated whiteboard — and by the time someone sits down to write the page, two things have already leaked away. The first is the reasoning: the trade-offs that were weighed, the option that nearly won, the constraint that ruled one path out. The second is the agreement itself. A page written by one person after the fact records their understanding of the decision, which isn’t always the team’s. Months later you can’t tell whether the page describes a consensus or a single author’s recollection of one.

Projan changes where the page comes from. Instead of writing up a decision after it’s gone cold, it’s present while the decision is being made, and it writes the page out of that.

Writing the decision as it’s made

Take an engineering team choosing an approach to event streaming. Normally this runs as a long Slack thread that resolves into “let’s go with Kafka,” and three weeks later someone writes a thin RFC page from memory.

With Projan facilitating, the discussion has a spine. It asks what throughput the system actually has to sustain and what the team is willing to operate. When someone says “managed queue is simpler,” Projan keeps that on the table as a real alternative rather than letting it evaporate. The cost of running a Kafka cluster gets raised; the team decides it’s acceptable and says why. Someone notes that exactly-once delivery is out of scope for this phase. Projan holds all of it — the winner, the runners-up, the reasons, the boundary.

Then it writes a Confluence page that reads like a decision record should:

The agreed approach — Kafka, with the throughput and operational reasoning that won it.
Alternatives considered — the managed queue, and the specific reason it lost, so nobody relitigates it in Q3.
Out of scope — exactly-once delivery, named explicitly so a future reader doesn’t assume it’s covered.

The page isn’t a summary of a decision. It is the decision, written as the team reached it, with the discarded options still visible.

A page, not a ticket

Be clear about what lands where. In Confluence, Projan produces one thing: a structured page — the RFC, the architecture decision, the agreed narrative. It does not create epics, stories, tasks or issues in Confluence, because Confluence isn’t a tracker and has none to create.

But an architecture decision usually implies work, and that work shouldn’t have to be re-typed. So the same session that wrote the Confluence page can send the implementation items to Jira or Linear as real tickets — “stand up the Kafka cluster,” “migrate the order service onto the new topic,” and so on. The decision gets one durable page in Confluence; the work gets tickets in the tracker your delivery team lives in. One conversation, two destinations, each getting the thing it’s actually good at holding.

Decide in Slack or Teams, document in Confluence

The decision doesn’t move into a new tool to get documented. Projan’s Slack and Microsoft Teams bots run the whole discussion in-channel — the throughput question, the managed-queue debate, the moment the team commits to Kafka. An engineering team that argues in a Slack channel keeps arguing there; the facilitation and the agreement happen in the room they’re already in. The web workspace is there for anyone who wants a quieter surface. Whichever it is, the agreed page lands in Confluence afterwards. The talking stays multiplayer and in-place; only the durable record moves into your knowledge base.

Setting it up

Connect Confluence once under Integrations → Confluence (OAuth with your Atlassian account) and pick the space the page should publish into. Run the session, reach the decision, and hit Export to Confluence — you review the page before it’s created. If the decision also needs tickets, point the same session at Jira or Linear and send the work there in the same breath. Nothing is written until you approve it, and nothing already in your space is touched.

Confluence is the record; Projan runs the decision

Keep Confluence as it is — the place your team’s documentation lives and the record everyone trusts. Projan isn’t competing for that role. It runs the conversation that produces the decision and writes the result into Confluence, so the page carries the agreement and the reasoning instead of a conclusion one person typed up alone. Confluence remains the record of what was decided. Projan is how the deciding — and the page worth reading afterwards — actually got done.