DEV Community: Mortise Apps

How do I put Jira reports in a Confluence page? Four native ways compared

Mortise Apps — Tue, 13 Oct 2026 14:00:00 +0000

Most weekly status pages in Confluence end up as screenshots of Jira, pasted on Monday and wrong by Wednesday. Confluence Cloud has four built-in ways to show live Jira data on a page instead, and they do quite different jobs. This page compares them side by side, says which report each one suits, and names the one gap none of them closes: totals per Atlassian team.

Short answer: Use the Jira Issues macro for a list or a count from a JQL query, the Jira Chart macro for a pie chart, a created-vs-resolved trend or a two-dimensional table by status, priority, assignee, fix version, component or issue type, and a Smart Link in embed view when you want a whole Jira dashboard, a single gadget, or a board, backlog or timeline on the page. None of the four can group or total by the Atlassian Team field, because Jira's own charts and gadgets cannot use Team as a statistic type. For per-team reports you need one macro per team, or an app.

Checked 7 Oct 2026: Atlassian's support pages for the Jira Issues macro, the Jira Chart macro, sharing Jira dashboards and boards in Confluence and Smart Links in Jira, plus three issues on Atlassian's public tracker (votes as read that day). We did not rebuild each option on a test site for this article; where Atlassian's pages are silent, we say so.

The four options at a glance

Option	What it shows	How you add it	Groups or totals by Team?	Notes from Atlassian's docs
Jira Issues macro ("Display Jira work items in a list")	A table of work items, one item, or a count, from JQL, a filter or a Jira URL	`/Jira` in the editor, then a query	No	You choose and reorder the columns; no group-by option is documented
Jira Chart macro	Pie chart, created vs resolved, two-dimensional table	`/Jira chart`, then a query	No	Pie and 2D axes: Status, Priority, Assignee, Fix version, Component, Issue type
Embedded Jira dashboard or gadget	The dashboard (or one gadget) as it looks in Jira	Copy the dashboard's or gadget's link in Jira, paste it on the page	No (gadgets cannot use Team as a statistic type)	Renders as a Smart Link in embed view
Embedded board, backlog, list or timeline	The Jira view itself, interactive	Copy the board's link, paste it on the page	Only if the board itself filters to one team	Viewers need access to the Jira space; filters reset when the page reloads

1. Jira Issues macro: lists and counts

The Jira Issues macro (Atlassian's documentation now calls it "Display Jira work items in a list") takes a JQL query, a saved filter or a pasted Jira URL. It has three views: a list (the default), a single work item, and a count view that shows "just the number of work items". In the list you pick which columns appear and drag them into order.

Use it for anything that is naturally a list: the open bugs in a release, everything in the current sprint, the work items flagged as blocked right now (flagged is not EMPTY AND statusCategory != Done).

What it does not do is break a list into groups or add up a column per value. A list of 60 work items with a Team column is still 60 rows. For a count per team, you need one macro in count view per team, each filtered on that team's ID (the JQL is "Team[Team]" = <team id>). We walked through that setup in how to show Jira work by team in a Confluence status page.

2. Jira Chart macro: three chart types, six fields

The Jira Chart macro draws three charts from a JQL query:

Pie chart, grouped by Status, Fix version, Assignee name, Priority, Component or Issue type.
Created vs resolved, the number of work items created against resolved over time.
Two-dimensional chart, a matrix whose X and Y axes come from Status, Priority, Assignee, Fix version, Component and Issue type.

That covers "open work by status" and "bugs by priority and assignee" well. Team is not in either list. Atlassian's documentation also notes that if the query includes items anonymous users cannot see, viewers "will be prompted to authenticate to view charts".

3. An embedded Jira dashboard or a single gadget

If the report already exists as a Jira dashboard, you can bring the whole thing into Confluence. In Jira, select the link icon at the top of the dashboard (or in the upper right corner of a single gadget) to copy its link, then paste the link into a page, blog post, whiteboard or database. Atlassian's page says it "will render as a Smart Link in embed view". The request for this, CONFCLOUD-70116 ("a macro that displays a Jira dashboard within the page"), is now closed as Fixed, with 572 votes on 7 October 2026.

This is the closest thing to "put my Jira report in Confluence" that ships with the product: whatever gadgets you have built in Jira appear on the page. It also inherits the gadgets' limits. On Jira dashboards, the Team field cannot be used as the statistic type in the Pie Chart, Issue Statistics or Two Dimensional gadgets. Atlassian tracks that gap as JRACLOUD-87808, open since October 2020 and still "Gathering Interest", with 649 votes when we checked on 7 October 2026.

Atlassian's dashboard-sharing page does not say what a viewer without access to the dashboard sees in the embed, so check that with a colleague's account before you send the page to stakeholders.

4. An embedded board, backlog, list or timeline

The same copy-and-paste works for a board or backlog: copy the link from the board's share icon, paste it, and it renders in embed view. Atlassian's Smart Links page says "users with access to the Jira space can view the Embed Smart Link of the board, list, timeline, calendar, or form", and that the embeds are interactive: viewers can change filters, create items inline (unless required fields block it) and adjust dates on a timeline.

Two details matter on a status page. First, "when the page with the embedded link is reloaded, the view will reset to today's date and all filters will reset to those that were applied when the URL was originally pasted", so set the filters you want before you paste. Second, an open suggestion on Atlassian's tracker, CONFCLOUD-83256, reports that the board embed shows only Jira's default fields, not columns you added yourself (1 vote, Gathering Interest, 7 October 2026).

A board embed is a good fit for a stand-up or a sprint review page. It is a view of the work, not a report: no totals, no trend.

Which one for which report

You want	Use
A list of specific work items that stays current	Jira Issues macro, list view
One number on the page (open bugs, items in review)	Jira Issues macro, count view
Open work by status, priority or assignee	Jira Chart macro, pie or two-dimensional
Is the backlog growing?	Jira Chart macro, created vs resolved
A dashboard you already maintain in Jira	Embed the dashboard or one gadget
The live board for a stand-up	Embed the board
Open, blocked and overdue work per team, velocity per team across boards, cross-team dependencies	Not covered natively: one macro per team, or an app

The gap: reports per Atlassian team

All four native options group by the fields Jira's charts know about. The Atlassian Team field is not one of them, so a page that should answer "how is each team doing?" falls back on one Jira Issues macro per team and per number. Six teams times three numbers (open, blocked, overdue) is eighteen macros and eighteen hand-written queries with team IDs in them, and a new or renamed team means editing the page. The step-by-step version of that workaround is still the best free option.

How TeamLens for Confluence fits

We make TeamLens for Confluence, a Confluence macro that reads Jira work from the same Atlassian site and groups it by the Team field directly. It went live on the Atlassian Marketplace on 7 October 2026. You insert it with /TeamLens, choose a report and a scope (Jira projects or any JQL, such as filter = 12345) and optionally some teams. The reports are Workload (to do, in progress, done in the last 30 days, blocked, overdue and open story points per team, with a "(no team)" row), Aging, Hygiene, Velocity across every board in the scope, and a who-waits-on-whom Dependencies matrix.

The limits, so you can rule it in or out quickly: it reads only the Jira on the same site, counts up to 3,000 work items per macro, needs Jira Software sprints for Velocity, shows a placeholder in PDF and Word exports, and viewers without Jira access see a "No access to Jira" message. Each viewer loads the report with their own Jira permissions; the app has one read-only scope (read:jira-work), no backend and no storage. It is free for sites with up to 10 users, with paid tiers above that billed by Atlassian. Details: the TeamLens for Confluence page and the getting-started guide.

FAQ

Can I put a Jira velocity chart in a Confluence page?

Not as a native macro: Atlassian's Jira macros are the list, count and chart macros described above, and the Jira Chart macro has no velocity chart. If your Jira dashboard has a gadget that shows what you need, copy that gadget's link and paste it into the page as an embed. For velocity per Atlassian team across several boards, see team velocity when teams do not match boards.

Are Jira macros in Confluence live or a snapshot?

The macros query Jira and embeds show the Jira view, so they reflect Jira rather than the day you built the page. Viewers may be asked to log in to Jira first, and what each person sees depends on their Jira access. For a frozen record, such as end-of-sprint numbers, take a screenshot or copy the values into a table.

Can the Jira Chart macro group by the Team field?

No. Atlassian documents six fields for the pie chart and the two-dimensional chart axes (status, priority, assignee, fix version, component, issue type), and Team is not one of them. The same limit applies to Jira's own dashboard gadgets (JRACLOUD-87808).

Do people need a Jira licence to see these on a Confluence page?

Atlassian's pages say viewers may be prompted to authenticate for the chart macro, and that users with access to the Jira space can view embedded boards. Plan for every reader of a Jira-backed status page to have Jira access; otherwise share a static copy.

Sources

Display Jira work items in a list, Atlassian Support - list, single item and count views; choosing and reordering columns. Read 7 Oct 2026.
Insert the Jira chart macro, Atlassian Support - the three chart types, the fields for pie and two-dimensional charts, the authentication prompt. Read 7 Oct 2026.
Share Jira dashboards in Confluence, Atlassian Support - copy a dashboard or gadget link, paste it, embed view. Read 7 Oct 2026.
Share a Jira board or backlog in Confluence, Atlassian Support - board and backlog embeds. Read 7 Oct 2026.
Smart Links in Jira, Atlassian Support - who can view embeds, interactivity, filters resetting on reload. Read 7 Oct 2026.
CONFCLOUD-70116, a macro that displays a Jira dashboard within the page - Closed, Fixed, 572 votes on 7 Oct 2026.
JRACLOUD-87808, Team field not supported for sorting on gadgets, JQL or boards - Gathering Interest, 649 votes on 7 Oct 2026.
CONFCLOUD-83256, Smart Link (embed view) only displays default Jira fields - Gathering Interest, 1 vote on 7 Oct 2026.

Originally published on the Mortise Apps blog.

Can monday.com change a task's status automatically when the tasks it depends on are done?

Mortise Apps — Mon, 12 Oct 2026 14:00:00 +0000

A question that comes up on the monday.com community: when a task's predecessors are finished, can monday move the next task to "Working on it" and tell its owner? There is one pre-built recipe for this. You can't build your own version, because monday's automation builder doesn't support the Dependency column. Whether the recipe waits for all predecessors is not documented.

Short answer: Yes, partly. In the automations center, searching "dependency" finds one pre-built template: "When a status changes to something, change the status of its dependency to something." It has four blanks (the status column, the trigger value, the Dependency column and the new value) and no "only if" condition. You can't build anything else from scratch: monday's own automations guide lists the Dependency column among the column types "not supported in any automations, including in the mapping of an item". The Dependency column itself only moves dates, never statuses. Nothing in monday's documentation says whether the recipe waits until every predecessor is done, so test it on a copy of your board before you rely on it.

The 60-second video version: Change status when dependencies are done (YouTube). In 20 seconds each: dependencies move dates, not statuses and hide done: what is ready to start.

Checked 6 Oct 2026: monday's support articles "Dependencies on monday.com" (updated 22 Sep 2026) and "Get started with monday automations" (updated 29 Sep 2026), and the automations center on a test board in our monday developer account. There we found the template and set it up. We did not run it on items yet, so this article says nothing about how it behaves with several predecessors.

The question

On the monday community, a user asked for an automation where, "when the status of a task (Predecessors) changes to 'Completed,' its (Successors) changes to 'Working on it' and notifies the assignee." An older thread ("Automations for Dependent Tasks") reached the same wall: the pre-built recipe "doesn't allow customization", and "you can't set up dependent column automations from scratch."

What the Dependency column does on its own

It moves dates. monday's support article describes the three dependency modes only in terms of dates:

Flexible: "Ensures no overlap between the dates of items that are dependent on one another."
Strict: "Adjusts an item's dates to reflect the exact time changes made based on the item it depends on."
No action: "Items will not shift automatically; they will solely display dependency relationships."

None of the three touches a Status column. A task whose predecessors are all done looks exactly as it did before, apart from its dates. Dependencies are "Available on Pro and Enterprise plans", and "You can only add one Dependency Column per board." (Our dependency modes article compares the three modes in detail.)

The one recipe that changes a status

In a board's automations center, a search for "dependency" returned one template on 6 Oct 2026, filed under "Connected & mirror columns":

When a status changes to something, change the status of its dependency to something

Filled in on our test board, it read: "When Status changes to Done, change the status of its Depends on to Working on it." The editor labels it "This is a pre-built template", and it has exactly those four blanks. There is no "and only if" condition and no notify step to fill in.

What that means in practice:

You can set the status, not who hears about it. monday's automations guide lists Dependency among the columns "not supported in the 'notify' field of a notification automation". To tell the next task's owner, use a separate status-change automation on that task ("When Status changes to Working on it, notify Person"). The notification then follows from the status change.
You can't add conditions. That rules out "only for this group" or "only if the date has arrived", and in particular "only if all predecessors are done".
You can't build it yourself. The same guide lists Dependency among the column types "not supported in any automations, including in the mapping of an item".

The part monday doesn't document: several predecessors

The question asked for the next task to start "when all dependencies are done". The template's wording doesn't say what happens when a task depends on two items and only one of them is finished. Neither of monday's support articles we read covers it. Before you rely on the recipe, test it on a copy of your board in two minutes:

Give one task two predecessors in the Dependency column.
Mark one predecessor Done and look at the task. Then mark the second one Done and look again.
Also check which way it goes. Did the recipe change the task that waits (the successor), or the task it waits on?

If the first Done already moves the task, the recipe answers "something finished", not "everything finished". Treat its status as a hint.

Two more limits come up in monday community threads and feature requests: the recipe reportedly doesn't work on multi-level boards (there is an open feature request for it), and it can't be customised. We have not tested either.

How to see which tasks are really ready

When the automation can't express "all predecessors done", look at the dependencies instead. That is what we built LinkLens Dependency Map for: a board view that reads the Dependency column and draws every chain on the board in one graph. Turn on hide done and every item whose status label counts as done drops out of the graph. A task with no blocker arrows left pointing at it is ready to start, however many predecessors it had. LinkLens doesn't change statuses itself; it shows you which ones are safe to change, and it is the quickest way to check what the recipe did. The app is in monday's marketplace review.

FAQ

Can monday.com automatically change status when a dependency is done?

There is one pre-built template, "When a status changes to something, change the status of its dependency to something". It has no extra conditions, and the custom automation builder doesn't support the Dependency column.

Can the monday.com automation wait until all predecessors are done?

monday's documentation doesn't say, and the template has no condition you could add. Test it on a copy of your board with a task that has two predecessors.

Can I notify someone through the Dependency column?

Not directly. monday's automations guide lists Dependency among the columns not supported in the "notify" field. Notify on the status change of the next task instead.

Do monday.com dependencies change statuses on their own?

No. Flexible and Strict modes move dates, and No action changes nothing. Statuses only change through an automation or by hand.

Does the Dependency column work in custom automations?

No. As of 29 Sep 2026, monday's automations guide lists it among the column types "not supported in any automations, including in the mapping of an item".

Sources

Set up an automation: When all dependencies are done, change status to something, monday community - the question.
Automations for Dependent Tasks, monday community - the recipe "doesn't allow customization".
Dependencies on monday.com, monday support - the three modes move dates; plans; one Dependency column per board.
Get started with monday automations, monday support - Dependency not supported in the "notify" field, nor in any automations.
Dependency automation for multi-level boards, monday feature request - the recipe on multi-level boards.

Can monday.com subitems depend on items or on other subitems?

Mortise Apps — Mon, 12 Oct 2026 04:48:01 +0000

A monday.com feature request titled "Allow dependencies between subitems/items/groups" has 53 votes and 16 replies, and has sat at "Gathering Feedback" for about three years. Its complaint: "it's only possible to connect dependencies between same-level items". monday's own help centre now describes a way to do it, with two conditions that are easy to miss.

Short answer: Yes, on a multi-level board. monday's support article on multiple levels of subitems says you can "set dependencies for subitems at any level" with the normal Dependent on column, "all the way down to level four", and see them on the Gantt chart. Two conditions: dependencies need the Pro or Enterprise plan, and multi-level subitems "are only available on newly created boards". On a classic board with one level of subitems, monday's dependency article lists limits instead: subitem summary columns are not supported in the dependency settings, and batch dependencies "cannot connect parent items to their subitems" on regular project boards. Groups are not mentioned as a dependency target in either article.

The 76-second video version: Can monday.com subitems depend on each other? (YouTube). Two Shorts: subitem dependencies are here, with a catch and batch links go to the parent (both public 11 Oct).

Checked 10 Oct 2026: monday's support articles "Multiple levels of subitems on monday.com" (updated 1 Oct 2026), "Dependencies on monday.com" (updated 22 Sep 2026), "All about subitems" (updated 15 Sep 2026) and "Cross-Project Dependencies" (updated 12 Aug 2026), plus the community request page. We have not built a multi-level board to test this; everything below is quoted from monday's documentation.

Two kinds of board, two answers

	Classic board (items + one level of subitems)	Multi-level board (new boards only)
Item depends on item	Yes, with the Dependency column (Pro and Enterprise)	Yes
Subitem depends on subitem	Not described in monday's dependency article	Yes, "at any level", down to level four
Parent linked to its own subitems	"On regular project boards, batch dependencies cannot connect parent items to their subitems"	Selecting several levels at once creates the link "at the highest level because subitems roll up to their parent items"
Dependencies on the Gantt chart	Yes, arrows between items	Yes; "the chart mirrors the structure of your board", each level can be expanded
Groups as a dependency	Not mentioned	Not mentioned

How it works on a multi-level board

From monday's article on multiple levels of subitems:

"You can add up to 4 levels of subitems". The parent item is level zero; the first subitem under it is level one, and so on.
Dependencies: "Available on Pro and Enterprise plans". You "use the Dependent on column as you normally would", expand an item with the arrow next to its name, and keep expanding "until you find the task you want to link".
"You can create dependencies all the way down to level four."
On the Gantt chart, "the chart mirrors the structure of your board, allowing you to expand each level and view dependencies across your project timeline."

The catch is in the setup section: "Multi-level subitems are only available on newly created boards." The FAQ repeats it: the feature is "in gradual release" and "available on newly created boards only". An existing board does not gain extra levels; you create a new multi-level board (or, for portfolio users, a new project from the "Multi-level sub-tasks project by monday.com" template, where the article says the feature is for projects on the Enterprise plan).

Other limits from the same article worth knowing before you move a plan over:

A level-zero item can have "up to 750 subitems total" across all levels, and a board holds up to 5,000 items including subitems.
Parent values are rollups: "You can only edit the lowest-level subitems."
"Mirror and Formula columns do not support roll up values", and granular permissions per subitem level are not supported.

What batch dependencies do across levels

monday's dependency article (updated 22 Sep 2026) describes batch dependencies, which link up to 50 selected tasks in one go:

"On projects with multiple levels of subitems, batch dependencies run in Strict mode by design."
"When you select items from several levels at once, the dependency is created at the highest level because subitems roll up to their parent items."
"You can also select subitems at the same level on a multi-level project and use batch dependencies to connect the subitems to each other."
"On regular project boards, batch dependencies cannot connect parent items to their subitems."

So batch linking across levels does not produce a subitem-to-item link; it lifts the link to the parent. To link one specific subitem to a task on another level, use the Dependent on column on that subitem.

Links to other boards

Dependencies stay on one board. For links between projects, monday has Cross-Project Dependencies, "Available on Enterprise plan", which lets you "link tasks across multiple project boards" and shows them in the project's Gantt view. On other plans, a Connect boards column links items across boards but does not move dates.

Seeing the chain

Whether your links sit between items or subitems, the Dependency column and the Gantt chart show them one task at a time. We make LinkLens Dependency Map, a board view that reads a board's Dependency column (or a Connect boards column) and draws every chain on the board as one graph, blockers on the left and circular dependencies in red (walkthrough). To be clear about its scope today: it reads the board's items, not subitems, so links between subitems on a multi-level board do not appear in it. The app is in monday's marketplace review.

FAQ

Can a monday.com subitem depend on another subitem?

Yes, on a multi-level board. monday's support article says you can set dependencies for subitems at any level, down to level four, with the Dependent on column. Multi-level subitems are only available on newly created boards, and dependencies need the Pro or Enterprise plan.

Can I add multi-level subitems to an existing monday.com board?

monday's article says multi-level subitems "are only available on newly created boards" and are in gradual release. To use dependencies across levels, create a new multi-level board or project.

Can a monday.com item depend on a whole group?

Neither of monday's articles on dependencies and multi-level subitems mentions groups as a dependency target. The documented links are between items and, on multi-level boards, subitems.

What happens if I batch-link tasks from different levels?

monday creates the dependency at the highest level, because subitems roll up to their parent items, and on multi-level projects batch dependencies run in Strict mode. Subitems on the same level can be batch-linked to each other.

Do monday.com dependencies work across boards?

The Dependency column links items on one board. Cross-Project Dependencies, on the Enterprise plan, link tasks across project boards; a Connect boards column links items across boards on other plans but does not shift dates.

Sources

Multiple levels of subitems on monday.com, monday support (updated 1 Oct 2026, read 10 Oct 2026) - four levels, dependencies at any level, new boards only, Gantt, limits.
Dependencies on monday.com, monday support (updated 22 Sep 2026, read 10 Oct 2026) - plans, batch dependencies across levels, parent and subitem limit, subitem summary columns.
All about subitems, monday support (updated 15 Sep 2026, read 10 Oct 2026) - subitem column structure.
Cross-Project Dependencies, monday support (updated 12 Aug 2026, read 10 Oct 2026) - Enterprise plan, links across project boards.
Allow dependencies between subitems/items/groups, monday community (53 votes, Gathering Feedback, read 10 Oct 2026).

Originally published on the Mortise Apps blog.

Jira 'blocks', 'is blocked by' or a custom 'depends on': which link type should you use for dependencies?

Mortise Apps — Sun, 11 Oct 2026 14:00:00 +0000

For dependencies in Jira Cloud, use the built-in Blocks link type, and read it as "A blocks B: B cannot finish (or start) until A is done". "Blocks" and "is blocked by" are not two link types; they are the two directions of the same one. A custom "Depends on" type works for people reading the work item, but Jira's own planning views will not see it unless an admin adds it: the timeline in a software space shows only Blocks links, and Plans treats all links as Blocks unless the Dependencies settings say otherwise. One JQL quirk to know before you build filters: issueLinkType = blocks cannot tell the blocking side from the blocked side.

One link type, two directions

Every Jira link type has three properties: a name, an outward description (how a work item affects others) and an inward description (how it is affected). The default Blocks type has the outward description "blocks" and the inward description "is blocked by". When you link ABC-1 to ABC-2 with "blocks", Jira stores one link; ABC-1 shows "blocks ABC-2" and ABC-2 shows "is blocked by ABC-1".

So the choice between "blocks" and "is blocked by" is only about which work item you are standing on when you add the link. The meaning to keep straight is the direction: the blocker is the one that has to happen first.

What each part of Jira does with link types

Where	What it reads	What that means for a custom "Depends on" type
Timeline in a software space	Only the Blocks link type, and only links between work items in the same space	Not drawn on the timeline
Plans (Premium and Enterprise)	By default, all work item links are treated as Blocks; a Jira admin can add other link types under Jira admin settings, Jira apps, Dependencies, with a Swap button to invert the direction	Counted, but possibly in the wrong direction until an admin maps it
JQL `issueLinkType`	Matches the link type's name and both descriptions	Searchable; give it a name different from its descriptions (below)
The work item view and board cards	Any link type, with its own wording	Readable by people

The timeline and Plans facts come from Atlassian's own pages, read on 8 Oct 2026 (sources below). The practical rule that follows: if a dependency should show up on the timeline, it has to be a Blocks link. If your site already uses a custom type for dependencies, ask your Jira admin to add it in the Plans Dependencies settings and check the direction with Swap, or your plans will read your dependencies differently from your team.

The JQL catch with "blocks"

Atlassian's documentation on link types says that JQL searches all three properties, the name and both descriptions, and that this makes it impossible to isolate one direction when the name equals one of the descriptions. That is exactly the case for the default Blocks type: its name is "Blocks" and its outward description is "blocks".

Query	What it returns on a default site
`issueLinkType = "is blocked by"`	Work items that are blocked by something (the inward side only)
`issueLinkType = blocks`	Work items with any Blocks link, in either direction, because "blocks" also matches the type's name

If you need a filter of blockers only, Atlassian's documented fix is to rename the link type (for example to "Blocking") so its name no longer equals the outward description. Their page warns that renaming can change what existing JQL filters return, so check saved filters, board filters and Automation rules that use the old name before you rename it.

A custom "Depends on" type has the same trap if you name it "depends on" and use "depends on" as the outward description. Give the type a neutral name such as "Dependency", with "depends on" and "is a dependency of" as its two descriptions, and each direction stays searchable on its own.

Which should you use?

Use Blocks for anything that must finish before something else can, if you want it on the timeline and in Plans without extra configuration. This covers most teams.
Use Relates for "worth knowing about" connections with no ordering. Keeping them out of Blocks keeps your dependency views honest.
Use a custom type only when you need a different meaning that Blocks would blur, for example a "Requires sign-off from" link for approvals. Name it so the name differs from both descriptions, and have your admin decide whether Plans should treat it as a dependency.
Be consistent about direction. Write it down in your team's working agreement: "the blocker gets the blocks link". A link added from the wrong side reads backwards to everyone who opens the work item.

Seeing the chain once the links are right

The work item view lists links one hop at a time, and the timeline shows only Blocks links inside one space. To read a whole chain across projects, LinkLens for Jira draws every link of the type you pick as a graph: choose Blocks, or your site's own custom type, from the Link type list (it lists your site's link types with both their directions). Loops show up as red dashed arrows, and Hide Done drops finished work so only live blockers remain. Our earlier posts show the whole blocker chain in a graph and how to find circular blocks links.

FAQ

Is "is blocked by" a different link type from "blocks"?

No. They are the inward and outward descriptions of the one default Blocks link type. A single link shows "blocks" on one work item and "is blocked by" on the other.

Does Jira have a "depends on" link type?

The default types described in Atlassian's link-type documentation include Blocks, Relates, Duplicates and the clone link types; "depends on" is something an admin adds as a custom type. If you add one, the timeline will not draw it and Plans needs to be told about it.

Why does `issueLinkType = blocks` return blocked work too?

JQL matches the link type's name as well as its descriptions, and the default type is named "Blocks" with the outward description "blocks". Atlassian's documented workaround is renaming the link type, for example to "Blocking".

Can the timeline show dependencies between projects?

Not the timeline in a software space: Atlassian's page says it shows only Blocks links between work items in a single space.

Which link type does LinkLens use?

The one you choose. LinkLens lists every link type on your site, Blocks by default, and draws the chain for that type. It is read-only and does not change your links.

Sources

Configure work item linking, Atlassian Support - name, outward and inward descriptions; JQL searches all three, so "blocks" cannot be isolated on the default Blocks type; renaming workaround and its warning. Read 8 Oct 2026.
Create or remove dependencies on your timeline, Atlassian Support - the timeline shows only the Blocks link type, between work items of a single space. Read 8 Oct 2026.
Configure Dependencies in Jira for your plan, Atlassian Support - Plans treats all links as Blocks by default; admins add link types under Dependencies, with Swap to invert. Read 8 Oct 2026.
Link work items, Atlassian Support - how links are added and shown on cards. Read 8 Oct 2026.

Originally published on the Mortise Apps blog.

Why free, docker stats and ps disagree about memory on your VPS (measured on a 1 GB box)

Mortise Apps — Sat, 10 Oct 2026 14:00:00 +0000

You log in to a small server to see how much memory is left, and every tool gives a different answer. We ran the usual ones on our 1 GB test server within a minute of each other and wrote down what each said.

Short answer: They count different things. free reports the whole machine, and its available column (192 MB here) is the one that tells you how close you are to trouble. docker stats added up to only 343 MB because it leaves out swap and the cache the kernel can drop: n8n showed 24.6 MiB while another 195 MB of it sat in swap. Adding up ps RSS gave 904 MB, more than the 769 MB free called used, because pages shared between processes are counted once per process. For "am I running out", read free's available and the swap line; for "who is using it", read each container's cgroup files, swap included.

Measured 8 Oct 2026, 05:15 UTC, over SSH on our test droplet coolify-test (DigitalOcean FRA1, $6 Basic, 1 vCPU, 1 GB RAM, Ubuntu 24.04.5, kernel 6.8, Docker 29.8.2), up 6 days 15 hours. Twelve containers: Coolify 4.3.23 and its services, n8n 2.10.2 with Postgres, Uptime Kuma 2, a small Node app. Commands: free -m, /proc/meminfo, docker stats --no-stream, each container's cgroup memory.current, memory.swap.current and memory.stat, every process's /proc/<pid>/smaps_rollup, and vmstat 1 5.

The four answers, one minute apart

Tool	What it said	What it counts
`free -m`, used	769 MB of 961 MB	All RAM that is not free and not cache the kernel can reclaim
`free -m`, available	192 MB	What new programs can still get without swapping, by the kernel's own estimate
`free -m`, swap used	972 MB of 2,047 MB	Pages pushed out of RAM to the swap file
`docker stats`, all 12 containers added up	343 MiB	Each container's RAM minus its inactive file cache; no swap
`ps` / `smaps_rollup`, RSS of every process added up	904 MB	RAM pages each process can see, shared pages counted again for every process that maps them
`smaps_rollup`, PSS of every process added up	531 MB	The same pages, with each shared page split between the processes sharing it

Nothing here is wrong. Each line answers a different question, and the gaps between them are where people misread a server.

Why docker stats looks so small

docker stats takes the container's cgroup memory and subtracts the inactive file cache. For Coolify's main container the cgroup said 164 MB in use with 12 MB of inactive cache, and docker stats showed 152 MiB: the same number with the cache taken off.

What it never shows is swap. On a box that swaps, that is most of the picture (the cgroup files were read 17 seconds after docker stats, so small differences between the first two columns are memory moving in between):

Container	docker stats	In RAM (cgroup)	In swap (cgroup)
Coolify (app)	152 MiB	164 MB	242 MB
n8n	24.6 MiB	29 MB	195 MB
Uptime Kuma	45.6 MiB	47 MB	110 MB
BuildKit (left over from a build)	36.9 MiB	19 MB	62 MB
Coolify realtime	17.1 MiB	18 MB	51 MB
Coolify Postgres	19.0 MiB	26 MB	30 MB
Sample Node app	5.5 MiB	10 MB	29 MB
n8n Postgres	13.2 MiB	17 MB	26 MB

Judged by docker stats, n8n is a 25 MB app. Counting its swap, it is about 220 MB, nine times more. If you size a server from docker stats on a machine that is already swapping, you will undersize it.

To read both numbers for one container on Ubuntu 24.04 (cgroup v2), use the full container id:

id=$(docker inspect -f '{{.Id}}' n8n-container-name)
cat /sys/fs/cgroup/system.slice/docker-$id.scope/memory.current       # bytes in RAM
cat /sys/fs/cgroup/system.slice/docker-$id.scope/memory.swap.current  # bytes in swap

Why adding up ps gives too much

RSS is every page a process has in RAM, including pages it shares with others: libraries, and memory a parent process shares with its workers. Coolify runs PHP-FPM workers, and each one reported about 25-28 MB of RSS, but only 4.6-6.3 MB of PSS, its fair share once the shared pages are split. Add up the RSS of several such workers and you count the same shared memory once for each of them.

Across the whole machine, RSS added up to 904 MB and PSS to 531 MB. PSS is the better number for "how much does this group of processes cost"; RSS is the right number only for a single process on its own.

Per-process swap has the same trap. The Swap: lines in smaps_rollup added up to 1,583 MB, while the machine only had 972 MB in swap. Shared pages that were swapped out show up in every process that maps them. The biggest single entries were still useful for ranking: n8n's Node.js process (it appears as MainThread) with 187 MB, then uptime-kuma with 100 MB. Use per-process numbers to find the biggest users, not to add up a total.

Why free's used is not the number to watch

free called 769 MB used and 69 MB free, which looks alarming on a 961 MB machine. Linux keeps file cache in RAM until something needs the space, so free memory on a busy server is always low. The kernel's own estimate of what is still usable, MemAvailable, was 192 MB, and that is what free prints as available.

The swap line matters more on a small box: 972 MB of pages did not fit in RAM. vmstat 1 5 showed the kernel reading up to 180 KB per second back from swap in the one-second samples (0, 152, 128 and 180 KB/s; the first line, 464 KB/s, is the average since boot). Swap that sits still is harmless; swap that is read back all the time means the working set does not fit.

Which number to use for what

Am I about to run out? free -m: the available column, then the swap line. Low available plus a busy si column in vmstat 5 means it is time for more RAM.
Which container is the problem? The cgroup files above, RAM plus swap. docker stats alone hides swap.
Which process is the problem? Per-process RSS or swap, to rank them. Do not add them up.
What does a group of processes really cost? PSS, from /proc/<pid>/smaps_rollup.

The commands for the swap ranking are on our one-page checklist: find what is using memory and swap.

What this box should be

This is the same server we watched for 5 days with Coolify, n8n and Uptime Kuma. Six days in, it still runs, with about 1.7 GB of demand on 1 GB of RAM. The numbers above are why we would not judge it from docker stats: that view says 343 MiB and suggests plenty of room, while the machine is a gigabyte into swap.

If you are choosing a size for a similar stack, prices read on 7 Oct 2026: a DigitalOcean Basic droplet with 2 GB is $12 a month and 4 GB is $24; Database Mart's Express Linux VPS has 4 GB for $5.99 with a shared IP address and US data centres only (details in Database Mart VPS pricing explained). We measured only the 1 GB droplet in this article.

FAQ

Why does docker stats show less memory than free?

docker stats leaves out swap and subtracts the cache the kernel can drop, and it only covers containers, not Docker itself, the system services or the kernel. On our server the 12 containers added up to 343 MiB in docker stats while free said 769 MB used and 972 MB in swap.

Does docker stats include swap?

No. On our server n8n showed 24.6 MiB in docker stats and had 195 MB in swap at the same moment, according to its cgroup's memory.swap.current.

What is the difference between RSS and PSS?

RSS counts every page a process has in RAM, including pages shared with other processes. PSS splits each shared page between the processes that share it. Our PHP-FPM workers had about 25 MB of RSS each but 5 MB of PSS. Adding up RSS over-counts; adding up PSS does not.

Which free column should I watch?

available. It is the kernel's estimate of memory that new programs can use without swapping. free is always low on a busy server because Linux fills spare RAM with cache.

Why do the per-process swap numbers add up to more than the swap in use?

Swapped-out shared pages are reported by every process that maps them. Ours added up to 1,583 MB with only 972 MB of swap in use. Use the per-process numbers to rank, and free for the total.

Originally published on Few Servers. Some links there are affiliate links; we only cover what we measured.

The best MCP servers for Claude Code that need no API key: the 5 we ran

Mortise Apps — Fri, 09 Oct 2026 14:00:00 +0000

Most "best MCP servers" lists are a page of logos. This one has five servers, and we ran every one on 6 October 2026. None of them needs an account, a card or an API key. For each server we counted its tools, timed it and noted what to watch for.

Short answer: These five work in Claude Code with nothing but a terminal command: Context7 (current library docs, 2 tools), Playwright MCP (drives a real browser, 25 tools), Microsoft Learn (Microsoft and Azure docs, 3 tools, remote, nothing to install), Fetch (reads any web page as markdown, 1 tool) and Git (reads and writes a local repository, 12 tools). All five showed "Connected" in claude mcp list, and every test call worked. Playwright MCP is the heavy one: about 780 MB of memory with one page open, and 55% of the tool definitions in this list. Fetch can read internal URLs and Git can commit and reset, so add those two deliberately.

The 3-minute video version: 5 MCP servers for Claude Code with no API key (YouTube). In 30 seconds each: the five, with their tool counts and what to know about the Fetch server.

Tested 6 Oct 2026, 04:38 to 04:45 UTC: a MacBook (Apple silicon) with Node.js 20.19.4, Python 3.12 and uv 0.12.23; Claude Code 2.1.284. Each local server was started with the same command Claude Code uses. We then recorded its handshake, its tools/list reply and one or two real calls with a small MCP client of our own, measuring memory with ps. Then we added all five to Claude Code in a scratch project with the commands below and ran claude mcp list. No API keys or accounts were used anywhere.

The five, side by side

Server	What it gives Claude Code	Tools	Key or account	Started in (first run / again)	Memory	Version we ran
Context7	Current documentation for libraries and frameworks	2	None (optional key for higher rate limits)	6.8 s / 1.7 s	195 to 341 MB	4.1.1 (npm, MIT)
Playwright MCP	A real browser it can open, read and click	25	None	3.8 s / 1.5 s	332 MB, 778 MB with a page open	0.0.83 (npm, Apache-2.0)
Microsoft Learn	Search and fetch over Microsoft and Azure docs	3	None	0.5 s (remote)	none on your machine	server 1.0.0 (hosted by Microsoft)
Fetch	Any URL as markdown	1	None	10.8 s / 0.7 s	61 to 158 MB	2026.8.18 (PyPI, MIT)
Git	Log, diff, status, and also commit, branch and reset	12	None	4.3 s / 0.7 s	95 to 133 MB	2026.8.18 (PyPI, MIT)

"First run" includes npx or uvx downloading the package; "again" is the second start with the package cached. Memory is the server and its child processes, read with ps after the tool list (and, for Playwright, after opening a page).

The commands

Each line is the one we ran, in the form the project's own README gives for Claude Code (or, where it gives none, the standard claude mcp add form). They add the server to the current project only; add --scope user to make one available in every project.

claude mcp add context7 -- npx -y @upstash/context7-mcp
claude mcp add playwright npx @playwright/mcp@latest
claude mcp add --transport http microsoft-learn https://learn.microsoft.com/api/mcp
claude mcp add fetch -- uvx mcp-server-fetch
claude mcp add git -- uvx mcp-server-git --repository /path/to/your/repo

Fetch and Git are Python packages run with uvx, so you need uv installed. Context7 and Playwright need Node.js. Microsoft Learn needs nothing local: Claude Code talks to Microsoft's server over HTTPS.

1. Context7: library docs that are not two versions old

What it does: two tools. One finds the library you mean, the other returns documentation snippets for your question. We asked it to resolve "fastapi" for the question "How do I add a background task in FastAPI?". In 2.5 seconds it returned five candidate sources with their snippet counts, the top one FastAPI's own site with 3,457 snippets.

Without a key it worked for everything we tried. Its README says a key gives "higher rate limits and private repositories", and its API guide describes the no-key tier as "Low rate limits and no custom configuration" without giving a number (Context7 API guide, read 6 Oct 2026). We did not hit a limit in a handful of calls. Our full Context7 test graded three of its answers against ones we had checked by hand: two right, one incomplete.

Cost of keeping it connected: 4,937 bytes of tool definitions, about a quarter of Playwright MCP's.

2. Playwright MCP: a browser your agent can use

What it does: 25 tools that open pages, read them, click, type, fill forms, take screenshots and read the console and network. We opened fewservers.com/g/ and asked for a snapshot: the page loaded in 8.9 seconds (that includes starting headless Chromium) and the snapshot was 6,916 characters.

What to watch: it is the heavy one. With one page open, the server and its browser processes took 778 MB. Its 25 tool definitions are 21,332 bytes, more than the other four servers together. Our Playwright MCP test has the details, including the 32,732-character snapshot of a longer page and the find tool that keeps snapshots small.

3. Microsoft Learn: the remote one

What it does: three tools, microsoft_docs_search, microsoft_code_sample_search and microsoft_docs_fetch, over Microsoft's documentation. It runs on Microsoft's servers, so nothing is installed and nothing uses your memory. The handshake took 0.5 seconds.

We searched "Azure Functions Python timeout limit consumption plan". The answer came back in 1.2 seconds, 21,770 characters long. The first result was a Microsoft Q&A thread rather than a documentation page, so check which source an answer came from before relying on it. Use this one if you write code against Azure, .NET or Microsoft 365; skip it otherwise.

4. Fetch: any page as markdown

What it does: one tool, fetch, which downloads a URL and turns the HTML into markdown, in chunks if the page is long. Our article page came back in 3.4 seconds as clean markdown: breadcrumbs, intro, byline. A page that is mostly a form (our /g/ page) came back as two lines, because the extractor keeps the main text and drops forms.

What to watch:

It quietly needs Node.js too. When Node is installed, Fetch uses a JavaScript HTML simplifier and runs npm install on the first fetch. On our machine that first fetch failed with an npm cache permission error ("returned non-zero exit status 1"). With a clean npm cache it took 6.0 seconds the first time and 1.9 seconds after that. If your first fetch fails, look at npm, not at the server.
It can reach your internal network. Its README warns that it "can access local/internal IP addresses". Do not add Fetch on a machine that can see admin panels or cloud metadata endpoints you don't want an agent reading.
It obeys a site's robots.txt by default for requests the model makes.

5. Git: your repository, including the write commands

What it does: 12 tools. Seven only read: status, three kinds of diff, log, show and branch. Five change things: add, commit, create branch, checkout, and reset, which the server itself marks as destructive. On a three-commit test repository, git_log, git_status and git_diff_unstaged each answered in 0.02 to 0.04 seconds.

What to watch: Claude Code can already run git in its shell, with your permission prompts. The difference is that this server's tools are separate MCP tools, and an "allow" you give them applies to commit and reset too if you allow the whole server. Pin it to one repository with --repository, and allow the read tools only. Add it when you want git history in an agent that has no shell. In Claude Code itself it adds little. Its README also says it "is currently in early development" and that its tools may change.

Which ones to add

Context7 if you write code against any library that changes often. It is light and needs no key.
Microsoft Learn if you work with Microsoft or Azure. It costs you nothing locally.
Playwright MCP when the agent has to check a real page: a deploy, a form, a bug report with steps. Remove it when you don't need it: it is the largest tool list and the biggest memory user here.
Fetch only if you need the agent to read pages as markdown in a client without web tools, and never on a machine with sensitive internal addresses.
Git mainly for clients without a shell; in Claude Code, prefer plain git with permission prompts.

Each server's tool definitions are loaded into Claude Code's context, and together these five come to about 39 KB. If you only need two of them, add two.

All five are listed, with thousands of others, in our MCP server directory, built from the official MCP Registry and refreshed daily.

FAQ

Which MCP servers work in Claude Code without an API key?

Context7, Playwright MCP, Microsoft Learn, Fetch and Git all worked with no key and no account when we ran them on 6 Oct 2026. Context7 accepts an optional key for higher rate limits.

How do I add an MCP server to Claude Code?

Run claude mcp add <name> -- <command> for a local server, or claude mcp add --transport http <name> <url> for a remote one, then check it with claude mcp list. Add --scope user to use it in every project.

Which MCP server uses the most memory?

Playwright MCP, because it runs a real browser: 778 MB with one page open in our test. The others used 61 to 341 MB, and Microsoft Learn none, because it runs on Microsoft's servers.

Is the Fetch MCP server safe to use?

Its own README warns that it can reach local and internal IP addresses. Use it on a machine where that is acceptable, and keep Claude Code's permission prompts on.

Do these servers slow Claude Code down?

Each one adds its tool definitions to the context: from 1,161 bytes for Fetch to 21,332 bytes for Playwright MCP. Local servers also start with Claude Code, from under a second to about 11 seconds on a first run while the package downloads.

How do I set the Jira Team field automatically from the assignee?

Mortise Apps — Thu, 08 Oct 2026 13:45:57 +0000

A question that keeps coming up on the Atlassian Community: when someone is assigned a work item, can Jira fill in the Team field with that person's team? Yes, with an Automation rule, and since September 2026 without the JSON that Atlassian's own knowledge base article still shows. What Jira does not have is a single step that looks up "the assignee's team": the rule needs one branch per team, and a person who belongs to several teams has no obvious answer.

Short answer: Build a Jira Automation rule with the trigger Field value changed on Assignee, an If/else block with one branch per team ("is the assignee in team A?"), and in each branch an Edit work item action that sets Team to that team. Atlassian's knowledge base shows the action as advanced JSON ({"fields": {"customfield_10001": "<team id>"}}); the native team picker that Atlassian started rolling out in the week of 21 September 2026 removes the JSON and the team ID lookups. There is no documented smart value that returns the assignee's team, so the rule cannot be written once for every team. Afterwards, check for assigned work the rule missed.

The 60-second video version: Set the Jira Team field from the assignee (YouTube). In 20 seconds: membersOf() works with teams, not by name.

Checked 5 Oct 2026: Atlassian's knowledge base article on updating the Team field from the Assignee, the Atlassian Cloud changelog for 21 to 28 September 2026, Atlassian's Community article on Teams in Automation, and the JQL functions documentation. We have not built this rule on a test site yet; where the documentation is silent, the article says so.

The question

On 6 September 2026 an Atlassian Community member asked whether automation could "find the first team of the user and assign the issue to this team", adding: "not hard coded I have many users." A month later the thread has no accepted answer. The two halves of that request get very different answers.

What Jira Automation can do

Atlassian's knowledge base article "Automation: Update the Team field based on the Assignee field" describes the rule:

Trigger: "Field value changed", to run when the Assignee field changes.
Condition: "an If/else block to check the assignee field and set the Team field accordingly".
Action: "Edit issue" with advanced field editing in JSON:

{ "fields": { "customfield_10001": "PUT TEAM ID HERE" } }

customfield_10001 is the Team field's ID on many sites, but the article warns to "check the Team Custom field ID on your instance", and the value is the team's ID, not its name.

Two newer changes make this easier:

Atlassian's Community article on Teams in Automation lists Edit work item setting a team, Field value changed triggering on the Team field, and a Work item fields condition that tests it ("If team field is Team Mobile...").
The Atlassian Cloud changelog for 21 to 28 September 2026, under "Native Teams support in Jira automation" (marked ROLLING OUT), says admins can "select teams directly in the Assign work item action and the User condition, removing the need for manual JSON workarounds or team ID lookups".

With the User condition taking a team, each branch reads naturally: if the Assignee is in team Payments, set Team to Payments. Because the change is rolling out, your site may not have the team picker yet; the JSON version works in the meantime.

What it cannot do

There is no "assignee's team" value. We found no documented smart value that returns the team a user belongs to, so the rule cannot say "set Team to whatever team the assignee is in". Every team needs its own branch. For a handful of delivery teams that is manageable; for dozens it is a rule to maintain whenever teams change.

People in several teams. Atlassian Teams are not exclusive: one person can be a member of several. "The first team" is not something Jira defines. Put the branches in the order you want to win (If/else stops at the first match), or keep people who sit in several teams out of the rule and set their work by hand.

Changes to teams do not re-run it. The rule fires when the assignee changes. If someone moves to another team, work already assigned to them keeps the old team until the assignee changes again or you bulk-edit it.

Check what the rule missed

Two JQL searches tell you whether the rule is doing its job:

assignee in membersOf("id:<teamId>") AND "Team[Team]" is EMPTY

Work assigned to a member of the team but with no team set. The JQL functions documentation says teams "don't currently work with team names" in membersOf(): use the ID from the team's profile URL, with the id: prefix.

assignee is not EMPTY AND issue in noTeam() AND statusCategory != Done

With TeamLens for Jira installed, noTeam() lists every work item with an empty Team field, across teams, without IDs. Saved as a filter on a dashboard, it should fall towards zero once the rule is running. TeamLens does not set the Team field itself; it shows where it is missing.

A rule that holds up

List the teams that own work, with their IDs from the team profile URLs.
Build the rule in one project first: Field value changed (Assignee), If/else with one branch per team, Edit work item setting Team.
Leave out a catch-all branch that clears the field: when no branch matches, the rule changes nothing, which is what you want for people outside the listed teams.
Run it for a week, then compare the noTeam() count before and after.
Note the rule in your team clean-up checklist: merging, archiving or deleting a team changes what each branch points at.

How TeamLens fits

TeamLens for Jira adds teamIn() and noTeam() to JQL, so the follow-up searches use team names instead of IDs (how they work). Its Team Statistics gadget has a "(no team)" row, which is the quickest way to see whether automation is keeping the Team field filled. It reads teams and work items; it does not change them.

FAQ

Can Jira set the Team field automatically?

Yes, with Jira Automation: trigger on the Assignee changing, check which team the assignee is in, and set the Team field with Edit work item. There is one branch per team.

Is there a smart value for the assignee's team?

Not that we could find in Atlassian's documentation on 5 Oct 2026. The rule has to check each team in its own branch.

Do I still need JSON and team IDs?

Not once the native team support reaches your site: Atlassian's changelog for the week of 21 September 2026 adds a team picker to the User condition and the Assign work item action. Until then, the knowledge base's JSON action with the team ID works.

What if a user is in more than one team?

Jira does not pick one. In an If/else block the first matching branch wins, so order the branches deliberately, or leave those users out of the rule.

How do I find work with no team?

"Team[Team]" is EMPTY in plain JQL, or issue in noTeam() with TeamLens for Jira. Combine it with assignee is not EMPTY to see assigned work the rule missed.

Sources

Can I auto populate team field based on assignee field?, Atlassian Community - the question, 6 Sep 2026.
Automation: Update the Team field based on the Assignee field, Atlassian knowledge base - trigger, If/else block, Edit issue with customfield_10001 JSON.
Atlassian Cloud changes Sep 21 to Sep 28, 2026 - "Native Teams support in Jira automation", rolling out.
Automate your workflows with Atlassian Teams in automations, Atlassian Community - Edit work item, Field value changed and Work item fields condition with teams.
JQL functions, Atlassian Support - membersOf() with teams needs the team ID; IN, NOT IN, WAS IN, WAS NOT IN.

Originally published on the Mortise Apps blog.

Deploy Coolify on a $6 VPS in 15 minutes, timed step by step

Mortise Apps — Sun, 04 Oct 2026 05:00:00 +0000

Coolify is the self-hosted alternative to Heroku, Vercel and Netlify: one server, a web UI, push-to-deploy for anything that runs in Docker. The project's own docs say you need 2 CPUs and 2 GB of RAM. We wanted to know whether the $6 DigitalOcean droplet (1 vCPU, 1 GB RAM, 25 GB SSD) is enough for a small team's side projects, so we installed it, timed every step and left it running.

Short answer: Yes, Coolify runs on DigitalOcean's $6 droplet (1 vCPU, 1 GB RAM) if you add a 2 GB swap file first. Measured on 1 Oct 2026: install script 172 s, first app deployed and answering in 210 s, build peak 720 MB RAM + 669 MB swap, idle footprint about 250 MB for Coolify itself. For more than two small apps, take the $12 plan.

Short version: it works, with one trick (a 2 GB swap file). The install script took 172 seconds, the first app was answering HTTP requests 210 seconds after clicking Deploy, and the measured steps from an empty account to a running app add up to just under 10 minutes (our wall clock said 23, because of a wrong base directory described below and a coffee). Memory after boot sat at 618 MB used with four containers healthy; the build peaked at 720 MB plus 669 MB of swap, which is why the swap file is not optional.

Watch it instead

The same steps as a 5-minute video, with the numbers on screen: Deploy Coolify on a $6 VPS in 15 minutes (YouTube). Two 30-second versions: the one number that decides 1 GB and the deploy that said Success while restarting.

What you need

A DigitalOcean account. New accounts need a payment method before the first droplet; the droplet is billed hourly ($0.009/h), so a one-hour test costs a cent.
An SSH key on your machine. If you do not have one: ssh-keygen -t ed25519 -f ~/.ssh/coolify.
About 15 minutes.

Step 1: create the droplet (1 minute)

In the DigitalOcean console choose Create → Droplets. Pick the region closest to you, then Ubuntu 24.04 (LTS) as the image.

Under Choose a Droplet Plan stay on Basic → Regular and pick the $6.00/mo plan: 1 vCPU, 1 GB RAM, 25 GB SSD, 1000 GB transfer. Skip the $4 plan: 512 MB is not enough for Coolify's four containers even with swap.

Under Authentication choose SSH Keys and add your public key. Do not use a root password; Coolify itself will later use SSH keys to talk to the server, and password logins are the first thing bots try.

Tick Improved Metrics and monitoring (free), give the droplet a name, and click Create Droplet. Ours showed a public IP after about 60 seconds.

Step 2: add swap (30 seconds)

This is the part that makes the 1 GB plan work. Log in and create a 2 GB swap file:

ssh root@YOUR_DROPLET_IP
fallocate -l 2G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
echo '/swapfile none swap sw 0 0' >> /etc/fstab
free -m

Without swap the install still completes, but the first docker build of a real app pushes demand past 1 GB and the kernel kills a container. With swap the build gets slow instead of dying; we measured the peak below (669 MB of swap in use during the build).

Step 3: run the Coolify installer (172 seconds)

One command, from the official docs:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

We timed it with date before and after. On the $6 droplet in Frankfurt:

Step	What it does	Time
1-2	OS check, apt packages (curl, wget, git, jq, openssl), SSH config	6 s
3-4	Installs Docker 29 and configures the network pool	57 s
5-8	Downloads compose files, writes `.env`, creates the localhost SSH key	under 1 s
9	Pulls and starts Coolify, Postgres, Redis, the realtime server and the Traefik proxy	109 s
	Total	172 s

When it finishes it prints Your instance is ready to use! and the URL http://YOUR_DROPLET_IP:8000. Four containers are running:

coolify           Up (healthy)
coolify-db        Up (healthy)
coolify-redis     Up (healthy)
coolify-realtime  Up (healthy)

Memory right after the install: 618 MB used of 961 MB, swap 32 MB. Disk: 7.1 GB used of 24 GB (Docker images are the bulk of it).

Step 4: create the root account and finish onboarding

Open http://YOUR_DROPLET_IP:8000 in a browser. The first screen creates the root user; do this straight away, because until you do, anyone who finds the port can.

After the account, a three-step onboarding wizard asks where to deploy. Pick This machine (the droplet itself); Coolify connects to it over its own localhost SSH key, checks that Docker is running and creates "My first project" with a production environment. The wizard offers to provision new servers on Hetzner, Vultr or DigitalOcean from inside Coolify, which is how you add a second box later.

The whole wizard is four clicks and took us under a minute; it ends on a "Setup complete" screen with the server, the project and the Docker engine all green, and a Deploy Your First Resource button.

Step 5: deploy your first app

The resource picker lists a few hundred one-click services (Sonarr, Plausible, n8n, Uptime Kuma and so on) plus the generic sources: public Git repository, private repository, GitHub app, Dockerfile, Docker Compose, Docker image. We chose Public Git Repository and pointed it at Coolify's own examples repo, https://github.com/coollabsio/coolify-examples, with the base directory /javascript/runtimes/nodejs (a tiny Fastify server on port 3000). Coolify inspects the repo, proposes Railpack as the build pack and shows the branch, port and base directory for review.

Click Continue, then Actions → Deploy. The deployment log streams live:

We timed it from the Deploy click to the first HTTP 200 from the public URL: 210 seconds. That breaks down into about 100 s of pulling the Railpack builder and Node base images (first deploy only; later deploys reuse them), 60 s of npm install on a 1 vCPU, and 20 s to start the container and for Traefik to pick up the route. The second deploy of the same app took 1 min 52 s.

Coolify gives every app a working URL immediately, on the free sslip.io wildcard DNS: http://<app-id>.64.226.72.55.sslip.io. Ours answered {"hello":"from nodejs #2"}.

One honest mistake worth recording: on our first attempt we typed the base directory as /nodejs (the folder had moved in the repo). Railpack happily built an image from an empty directory, the deployment reported Success, and the container then restarted every few seconds because it had nothing to run. Check the runtime logs after your first deploy, not just the green badge.

What the build did to a 1 GB server

This is where the swap file earns its keep. Our sampler logged memory every five seconds during the build:

Moment	RAM used	Swap used	Load (1 vCPU)
Idle, Coolify only	618 MB	32 MB	0.5
`npm install` running	765 MB	498 MB	4.2
Image export, peak	720 MB	669 MB	7.0
App running, 5 min later	648 MB	478 MB	0.4

Without the 2 GB swap file, the peak would have been about 1.4 GB of demand on a 961 MB box: the kernel's OOM killer would have taken out either the build or Coolify's own database. With swap, the build was slow (load 7 on one core) but finished. The Fastify app itself uses 31 MB.

Is 1 GB enough? The verdict so far

Resident memory per container after the deploy, from docker stats:

Container	Memory
coolify (the app)	150 MB
coolify-proxy (Traefik)	38 MB
coolify-realtime	25 MB
coolify-db (Postgres)	23 MB
coolify-sentinel	9 MB
coolify-redis	7 MB
your app (Fastify)	31 MB
Total	283 MB

Coolify's own footprint is about 250 MB; the rest of the "used" figure is the kernel, Docker and page cache. Disk after one build: 11 GB of 24 GB (base images and the build cache are the bulk; Coolify's cleanup job reclaims the cache weekly).

So: for one or two small apps, a static site, or a private tool, the $6 droplet with swap is fine and we are leaving ours running. We will update this section with the 7-day numbers (memory trend, swap, any restarts) once we have them.

What the $6 plan cannot do

Build large Node or Rust projects on the server. Builds are the memory peak; for anything heavier than a static site or a small Express/Flask app, build elsewhere (GitHub Actions) and have Coolify pull the image.
Run a database per app comfortably. One Postgres is fine; three is not.
Survive a traffic spike without swapping. If an app matters, the $12 plan (2 GB) is the realistic minimum and still far cheaper than one Heroku dyno.

Cost comparison

Option	Monthly	Notes
DigitalOcean $6 droplet + Coolify	$6.00	Unlimited apps within the box, your own domain, free SSL via Traefik
DigitalOcean $12 droplet + Coolify	$12.00	The comfortable size for a small team
Heroku Eco dyno	$5 per app, sleeps	One app, sleeps after 30 min idle
Render starter	$7 per service	One service
Railway hobby	$5 + usage	Usage-based

For a team running three or four small services, a single Coolify box replaces $20-40 of PaaS fees. The trade: you own the updates and backups.

FAQ

Does Coolify work with 1 GB of RAM?

Yes, with a swap file. Coolify's own containers use about 250 MB; the problem is the build step, which peaked at 720 MB of RAM plus 669 MB of swap in our test. Without swap the kernel kills a container during the first real build. With a 2 GB swap file the build is slow but completes.

How long does the Coolify install take?

172 seconds on a $6 DigitalOcean droplet in Frankfurt, measured from running the official install script to the "Your instance is ready" message. Most of that is installing Docker (57 s) and pulling the Coolify images (109 s).

How much does it cost to run Coolify on DigitalOcean?

$6.00 a month for the droplet ($0.009 an hour), plus $1.20 a month if you turn on weekly backups. Coolify itself is free and open source. There is no per-app charge, so the cost does not change when you add a second or third small app.

Should I use the $4 droplet instead?

No. The $4 plan has 512 MB of RAM and 10 GB of disk; Coolify's images alone used 7 GB in our install and the four core containers need more than 512 MB before any app runs.

Which plan for a small team running several apps?

The $12 droplet (2 GB RAM, 50 GB SSD) is the realistic minimum once you run three or more services or any database next to your apps. It is still far cheaper than one dyno or service on a hosted PaaS.

Next steps

Point a domain at the droplet and set it in Coolify's settings; Traefik issues Let's Encrypt certificates automatically.
Enable DigitalOcean's weekly backups ($1.20/month on this plan) or Coolify's own S3 backups.
Lock the server down: which ports Coolify needs and which to close.
Wondering whether 1 GB is really enough? The docs versus what we measured.
Know what the droplet costs before the invoice arrives: DigitalOcean droplet pricing explained.
Read our Coolify vs Dokploy comparison once it is published; both ran on this same droplet.

Originally published on Few Servers.

See the whole blocker chain in Jira: from a flat list of issue links to a dependency graph

Mortise Apps — Fri, 02 Oct 2026 05:30:48 +0000

A blocker chain in Jira is a sequence of issues joined by blocks / is blocked by links: F1 blocks F2, F2 blocks F3, F3 blocks F4. Jira records every link faithfully but shows them as a flat list inside one issue at a time, so the fact that F4 is ultimately waiting on F1 is never visible anywhere. A dependency graph draws the whole chain as cards and arrows on one canvas, blockers on the left and blocked work on the right. LinkLens for Jira draws that graph for a whole project or for the issue you are looking at.

What Jira gives you today

Atlassian's documentation is clear that linked work items exist "to surface, understand, and manage dependencies". Each link type has two labels, one per direction: blocks seen from the blocker, is blocked by seen from the blocked issue. It is one link, one type, read from two sides.

The issue view lists those links under Linked work items, grouped by label. Boards can show a small linked-items icon on cards. Plans (Advanced Roadmaps) draws dependency lines on a timeline for the issues in a plan. All three show what is directly attached to the issue in front of you. None of them follows the chain.

The request for a project-wide picture is not new. JRASERVER-2544, "Graph link dependency map", was filed in 2003 and eventually closed as won't fix. Twenty years later the flat list is still the default, which is why a whole category of Marketplace apps exists to draw the graph.

A real example: the payments feature and the infrastructure ticket

A storefront team is shipping "Apple Pay and Google Pay in checkout" this sprint. On the issue view it shows one link: is blocked by "Save payment method for next purchase", which is in progress. Looks fine.

Open that blocker and it has its own link: is blocked by "Rotate API keys for payment gateway", a task in the platform team's project, still in the backlog. Open that one and there is a fourth hop: the key rotation waits on "Shared auth service upgrade" in a third project, owned by a team that is not in the sprint review.

Nobody lied and nobody forgot to link anything. The chain is four issues long, spans three projects and two teams, and the only way to discover it is to click through issue after issue. The sprint review is where it gets discovered, three hops too late.

How to do it with LinkLens

LinkLens adds two views and one rule: pick one link type, and both of its directions are used automatically.

The Dependencies page (whole project)

Open the project and select Dependencies in the project sidebar.
In Link type, pick Blocks (blocks / is blocked by). It is preselected on most sites.
Read the canvas left to right. An arrow from A to B means A blocks B. The legend under the canvas restates the rule for whatever type you picked.

For the storefront project the payments chain appears as one row: key rotation, then save-payment-method, then Apple Pay, then the guest checkout story it blocks in turn. The "Shared auth service upgrade" issue from the other project shows as a dimmed, dashed card labelled outside scope, so the cross-project blocker is visible without leaving the page. Widen the JQL scope to project in (SHOP, PLAT) and its own chain is drawn too.

Only issues that have at least one link of the chosen type are drawn; the rest are counted in the stats line ("17 issues in scope, 16 in chains") so the picture stays readable. Hide Done removes finished issues and their links. Click a card to pin its whole upstream and downstream chain while everything else fades; double-click to open the issue. PNG exports the graph with a legend for a Confluence page or a slide.

The Dependency chain panel (one issue)

Open any issue. Select the apps button under the title and choose Dependency chain.
Set Depth to 3 to 5 hops.

The current issue sits highlighted in the middle. Everything to its left blocks it directly or indirectly; everything to its right waits on it. For the Apple Pay story that is the whole four-issue chain on one small canvas, including the other projects.

Choosing the link type

Choose the type whose outward label means "must happen first". Blocks is the usual one. If your admins created a custom type such as Depends on, check which side is the outward label; if the arrows look reversed, the type's labels are defined the other way round.

What LinkLens cannot do

It is read-only in this version: it draws links and does not create or delete them, so use Jira's Link work item action to fix a chain. It draws one link type at a time by design; a chain that mixes blocks and depends on has to be viewed twice. Parent and child relationships (epic to story, story to sub-task) are not drawn as edges yet. The project page caps at 2,000 issues per graph and the issue panel at 300 issues and 5 hops. Links to issues on a different Atlassian site are not followed, and it is Jira Cloud only.

FAQ

Does it work across projects?

Yes. Linked issues outside the current scope are shown as dimmed cards so cross-project blockers never hide. Set the JQL scope to several projects to draw their chains in full. The issue panel follows cross-project links by default.

Does it show issues I am not allowed to see?

No. Every read runs as the person viewing the graph, so Jira's permissions apply and hidden issues are absent, including as external ends.

What does it cost?

Free for sites with up to 10 users. Above that about USD 0.20 per user per month, roughly USD 10 a month for a 50-user site, billed by Atlassian with a 30-day trial. It is on the Atlassian Marketplace; details are on the LinkLens page.

Sources

Link work items, Atlassian Support - link types have outward and inward descriptions; where links are shown.
JRASERVER-2544, Graph link dependency map - the 2003 request for a project-wide dependency map, closed won't fix.
Dependencies in Advanced Roadmaps, Atlassian Documentation - incoming and outgoing dependencies as blocks / is blocked by.

Originally published on the Mortise Apps blog.

How to see every dependency chain on a monday.com board

Mortise Apps — Thu, 01 Oct 2026 20:42:26 +0000

To see how work on a monday.com board depends on other work, you add a Dependency column and pick, for each item, the items it waits on. monday.com then draws each link as a line in the Gantt view and can push dates when a predecessor moves. What it does not show is the structure: which item sits at the start of a chain, how many items a slip would drag along, and where two items wait on each other in a loop. This article covers what the built-in tools do, how far you get with them, and how to see the whole picture with LinkLens Dependency Map, our board view.

What monday.com gives you out of the box

The Dependency column stores, for each item, the items it depends on. Three things use it:

The Gantt view draws a connector line from each predecessor to the item that waits on it, laid out on the Timeline column. Good for one release plan on one screen.
Dependency automations, such as "when a date changes, push the dependent items". These keep dates consistent but say nothing about risk.
Connect boards columns, which link items across boards. They are not dependencies by themselves, but many teams use them that way: a vendor contract on one board that a launch on another board waits for.

The monday.com support article on dependencies covers the setup. It is quick, and for a short plan it is enough.

Where the Gantt view stops

The Gantt view answers "what comes before this bar". It struggles with three questions that project managers ask every week.

How far does a delay spread? If CMS setup slips, the Gantt shows the line to Content migration. It does not show that SEO redirects, QA testing and Launch are behind that, five items deep. You follow the lines by hand.

Which item is the real bottleneck? The item with the most work behind it is rarely the one that looks urgent. A small task that three chains pass through is the one to staff first, and nothing in the Gantt ranks items that way.

Where are the loops? A loop (A waits on B, B waits on C, C waits on A) means none of the three can finish first. Loops usually arrive through Connect boards columns, imports, automations or the API rather than by hand, and a Gantt line has no way to say "this one goes backwards".

Items on other boards add a fourth problem: the Gantt only shows one board, so a cross-board dependency is invisible until someone opens the other board.

What you can do natively

Question	Built-in answer	Effort
What comes right before this item?	Dependency column, Gantt connector	Low
What is everything upstream of this item?	Follow Gantt lines by hand, or a formula per hop	High, breaks past two hops
Which items block the most work?	No native view	Not available
Are there circular dependencies?	No native check for chains longer than two	Not available
Dependencies across boards	Enterprise cross-project dependencies, or Connect boards columns read by hand	Plan-dependent
A report for stakeholders	Export the Gantt as an image	Shows lines, not risks

If you only need the first row, stop here; monday.com does it well.

See the whole structure: LinkLens Dependency Map

LinkLens Dependency Map is a monday.com board view. Add it to a board, pick the Dependency column (or a Connect boards column) and it draws every chain on the board as one graph: blockers on the left, blocked work on the right, separate chains stacked, items without links counted but not drawn. Each card shows the item's group and status.

What that gives you, using the questions above:

Delay spread. Hover any item and its whole chain lights up, upstream and downstream. Double-click to open the item.
Bottlenecks. The layout puts the first blockers on the left; the item with the most cards to its right holds up the most work.
Loops. A circular dependency is drawn with a red dashed arrow and every loop is listed under the map.
Other boards. With a Connect boards column, linked items on other boards appear as dashed outside cards with their board name and status.
Focus. Hide done removes finished items and their links, so what remains is the work that is really blocked today.

The dependency health report

The Report button turns the same data into a document you can hand to stakeholders: a 0-100 dependency health score, every risk found on the board explained in plain English with the items involved and a suggested fix (circular dependencies, overdue and stuck blockers, bottlenecks, stale blockers, date conflicts), which items are predicted to finish late and by how many days, when the open linked work is likely to clear at the recent pace, and 8-week trends of links added against blockers finished. It downloads as PDF or HTML.

The predictions come from the board, not from guesses: LinkLens follows each chain forward from today using the Timeline or Date column, and if a blocker ends after the item behind it is due, that item is predicted late by the difference. Everything is calculated in your browser; no board data leaves monday.com.

Ask Sidekick instead of opening the view

LinkLens also adds a tool to monday Sidekick, monday.com's AI assistant. Turn the LinkLens tool on and ask, in the chat, "What is blocking Launch?", "What does CMS setup delay?" or "Are there circular dependencies on this board?". Sidekick calls LinkLens for the answer, which comes from the board's real links.

What LinkLens does not do

It does not change dates, create links or write to your board; it is read-only. It does not replace the Gantt view for scheduling. And it reads items as the person viewing the board, so it never shows anyone an item they could not already open.

FAQ

Do I need the Enterprise plan for cross-board dependencies?

Not for LinkLens: it reads Connect boards columns, which exist on every plan that has them, and shows linked items on other boards as outside cards. monday.com's own cross-project dependencies feature is separate.

Does the Dependency column allow circular dependencies?

Loops rarely come from typing them in by hand. They arrive through Connect boards columns, board imports, automations and the API. LinkLens draws them in red and lists them so you can remove the link that points backwards.

Can viewers and guests see the map?

Yes. The view is read-only, so viewers and guests get the same map and report; only their view settings are not saved.

Sources

Dependencies on monday.com, monday.com support: setting up the Dependency column and how the Gantt view and automations use it.
Working with the dependency column, monday.com developer documentation: how dependency data is stored and read.
Task dependencies in project management, monday.com blog: dependency types and why chains matter.

Originally published on the Mortise Apps blog.

Search Jira by team name: teamIn() and noTeam() instead of Team UUIDs in JQL

Mortise Apps — Wed, 30 Sep 2026 14:35:07 +0000

In Jira Cloud, a JQL search on the Atlassian Team field has to use the team's UUID, not its name. "Team[Team]" = 36885b3c-1bf0-4f85-a357-c5b858c31de4 works; "Team[Team]" = "Payments" returns nothing. TeamLens for Jira adds two JQL functions that remove the copy-and-paste: issue in teamIn("Payments") matches issues by team name, with a trailing * for prefixes, and issue in noTeam() returns every issue whose Team field is empty. Both work in filters, boards, dashboards, Jira Service Management queues and Automation.

Why names do not work in JQL

The Team field is a custom field (typically customfield_10001) whose stored value is a team id, a UUID such as 36885b3c-1bf0-4f85-a357-c5b858c31de4. Atlassian's developer documentation for the field shows the JQL form directly: "Team[Team]" = <uuid>. The team's display name is metadata attached to that id; JQL never compares against it.

Atlassian recorded the consequence years ago in JRACLOUD-84663, "JQL Search for Team does not Recognize Team Names". The ticket is now closed, and a related ticket (JSWCLOUD-19523) notes that Jira has been rolling out team name lozenges in the JQL editor, which helps when you type a query interactively. It does not help when the query lives in a saved filter, a board, an Automation rule or a queue definition, where you still see and maintain the raw UUID.

Finding a team's UUID means opening the team's profile page and copying the last segment of its URL. Do that for eight teams, paste them into a filter, and you have a query nobody can read and nobody dares to edit.

A real example: one JSM queue per support team

A service desk has three tiers of support, each an Atlassian Team so that Jira Plans and the Team field on requests line up. The service manager wants a queue per tier and a board per tier that only shows that team's open requests.

The native version of each queue filter looks like this:

"Team[Team]" = 5f2a0c1e-8f4b-4b2e-9c6d-2c1a4f7b9d31 AND statusCategory != Done

Six months later the Tier 2 team is renamed and merged with a new team. Whoever inherits the queues has three UUIDs and no idea which is which. The filter for "requests nobody has picked up" is worse: there is no function for "empty Team", so it is written as "Team[Team]" is EMPTY, which works but is not something a queue owner will discover on their own, and it cannot be combined with "or belongs to any tier whose name starts with Tier".

How to do it with TeamLens

TeamLens registers two functions. Because Jira exposes app functions through the issue in ... form, that is how they are written.

Queue per team

issue in teamIn("Tier 1 Support") AND statusCategory != Done

Names are matched case-insensitively against the team's display name. If no team matches, JQL shows an error naming the value, so a typo fails loudly instead of returning an empty queue. A raw UUID is also accepted, so existing filters can be migrated one clause at a time.

All support tiers at once

issue in teamIn("Tier*") AND status = Open

The trailing * matches every team whose name starts with the prefix. New "Tier 4 Support" team next year? The queue picks it up with no edit.

Everything except one team

issue not in teamIn("Tier 1 Support")

Work nobody owns

issue in noTeam() AND statusCategory != Done

Put that one behind a scheduled Automation rule that runs every Monday and comments or emails the service manager, and unowned work stops hiding.

Steps in Jira:

Install TeamLens from the Marketplace (Jira admin, under a minute, no configuration).
Open the issue navigator, switch to JQL, and type issue in teamIn("Your Team Name"). The autocomplete lists the app functions after the first character.
Save it as a filter, then use the filter for a board, a JSM queue, a dashboard gadget or an Automation condition exactly as you would any other filter.

The team list is cached for ten minutes, so a team renamed a moment ago may still resolve under its old name for a short while.

Migrating existing UUID filters

You do not have to rewrite every filter on day one. Because teamIn() accepts a raw UUID as well as a name, a filter such as "Team[Team]" in (uuid-a, uuid-b) can become issue in teamIn("uuid-a", "uuid-b") first, then have each id swapped for the team's name as you touch it. Keep one saved filter per team with a clear name ("Team: Tier 1 Support, open") and point boards, queues and gadgets at the filter rather than repeating the JQL, so a rename means editing one place. A useful check after migration is a dashboard gadget with issue in noTeam() AND created >= -30d: if it is not close to zero, the Team field is not being set on new work and the per-team views are undercounting.

What TeamLens cannot do

The functions match team names and ids; they cannot match team members, because the Teams API only answers a human's API token, not an app's own auth context, so apps cannot read Atlassian Team membership on their own yet (app access is tracked as JRACLOUD-92072). A myTeams() function that returns the issues of every team the current user belongs to is planned for when that API opens. The functions are also written as issue in teamIn(...), not Team in teamIn(...), because that is how Jira Cloud exposes every app-provided JQL function. And they are Cloud only.

FAQ

Does teamIn() work in Jira Service Management queues?

Yes. Queues are JQL filters, and app functions are allowed in them. issue in teamIn("Tier 2 Support") AND status = Open is a valid queue definition.

Can I use these functions in Automation rules?

Yes, both as a JQL condition inside a rule and in the JQL of a scheduled trigger. The weekly "unowned work" rule above is the typical use.

Is this cheaper than building it myself?

There is no do-it-yourself route: JQL functions can only be added by apps. TeamLens is free for sites with up to 10 users and USD 1 per user per month above that, with a 30-day trial, on the Atlassian Marketplace. Details are on the TeamLens page.

Sources

Team field in Jira REST API, Atlassian Developer - the UUID value and the "Team[Team]" = uuid JQL form.
JRACLOUD-84663, JQL Search for Team does not Recognize Team Names - JQL accepts team ids, not names.
JSWCLOUD-19523, JQL Search for Team does not Recognize Team Names - team name lozenges in the JQL editor.
JRACLOUD-87808, Team field not supported for sorting on gadgets, JQL or boards - the wider Team field JQL limitations.
Teams in Jira projects, Atlassian Support - UUIDs must be used when referencing teams in workflows.

Originally published on the Mortise Apps blog.

DEV Community: Mortise Apps

How do I put Jira reports in a Confluence page? Four native ways compared

The four options at a glance

1. Jira Issues macro: lists and counts

2. Jira Chart macro: three chart types, six fields

3. An embedded Jira dashboard or a single gadget

4. An embedded board, backlog, list or timeline

Which one for which report

The gap: reports per Atlassian team

How TeamLens for Confluence fits

FAQ

Can I put a Jira velocity chart in a Confluence page?

Are Jira macros in Confluence live or a snapshot?

Can the Jira Chart macro group by the Team field?

Do people need a Jira licence to see these on a Confluence page?

Sources

Can monday.com change a task's status automatically when the tasks it depends on are done?

The question

What the Dependency column does on its own

The one recipe that changes a status

The part monday doesn't document: several predecessors

How to see which tasks are really ready

FAQ

Can monday.com automatically change status when a dependency is done?

Can the monday.com automation wait until all predecessors are done?

Can I notify someone through the Dependency column?

Do monday.com dependencies change statuses on their own?

Does the Dependency column work in custom automations?

Sources

Can monday.com subitems depend on items or on other subitems?

Two kinds of board, two answers

How it works on a multi-level board

What batch dependencies do across levels

Links to other boards

Seeing the chain

FAQ

Can a monday.com subitem depend on another subitem?

Can I add multi-level subitems to an existing monday.com board?

Can a monday.com item depend on a whole group?

What happens if I batch-link tasks from different levels?

Do monday.com dependencies work across boards?

Sources

Jira 'blocks', 'is blocked by' or a custom 'depends on': which link type should you use for dependencies?

One link type, two directions

What each part of Jira does with link types

The JQL catch with "blocks"

Which should you use?

Seeing the chain once the links are right

FAQ

Is "is blocked by" a different link type from "blocks"?

Does Jira have a "depends on" link type?

Why does issueLinkType = blocks return blocked work too?

Can the timeline show dependencies between projects?

Which link type does LinkLens use?

Sources

Why free, docker stats and ps disagree about memory on your VPS (measured on a 1 GB box)

The four answers, one minute apart

Why docker stats looks so small

Why adding up ps gives too much

Why free's used is not the number to watch

Which number to use for what

What this box should be

FAQ

Why does docker stats show less memory than free?

Does docker stats include swap?

What is the difference between RSS and PSS?

Which free column should I watch?

Why do the per-process swap numbers add up to more than the swap in use?

The best MCP servers for Claude Code that need no API key: the 5 we ran

The five, side by side

The commands

1. Context7: library docs that are not two versions old

2. Playwright MCP: a browser your agent can use

3. Microsoft Learn: the remote one

4. Fetch: any page as markdown

5. Git: your repository, including the write commands

Which ones to add

FAQ

Which MCP servers work in Claude Code without an API key?

How do I add an MCP server to Claude Code?

Why does `issueLinkType = blocks` return blocked work too?