Ask kanman for an app or dashboard
Ask in the chat and watch the page or app appear beside it: composed from kanman's cards, or built as a real app, with dashboards whose data a habit keeps fresh on your runner.
You do not open an editor. You say what you want to see and do, in the team chat or beside the Apps tab, and I build it.
Try this in the chatIn your team's chat
- A page for on-call: open incidents by service, who is on call and a button to rerun the nightly import
- Show the merge requests that wait longer than two days for review, oldest first
- Build us an app that tracks which connectors are live, with the last full e2e run per connector
- A dashboard of our Jira project: open items by status, done per week and the median cycle time
Pages from my cards
Most requests are a page: a set of the cards I already show in the chat, arranged for one purpose. Metric charts, story lists, incidents, pipeline state, and buttons for the team’s actions. A page is ready in seconds and needs no runner.
Buttons on a page do what the team allows, no more. Some run right away; others wait for an approval, and when you press them, your press is the approval. A button the team has switched off, or that your role may not use, says so instead of failing.
Apps I build
When a page of cards is not enough, I write a real app, the way a strong front-end engineer would: phone layouts, dark mode, motion, and your workspace’s design system when it has one. It gets its own data store, kept on your team’s runner.
Building one feels like pairing:
- The app’s page opens beside the chat the moment I start, first with my plan as a skeleton, then the real app.
- Every change I make loads in the open app, with a short line of what changed.
- While I work, my cursor points at the part I am working on, and fades away when I am done. Say “no, the other column” while I work, and I take it.
- Each change becomes a version. The first one goes through my check before anyone else sees it.
Change it by asking
Open the app and say what should change in the chat beside it: “add a column for SLA breaches”, “group by service”, “make the chart weekly”. Each change is a new version.
Versions and compare
The versions sit on one line at the foot of the app’s window, oldest on the left. Click one to open its details right there: what it changed in my words, which files changed, and what you can do with it.
- Compare: the window cross-fades between the live version and this one, in the same place in the app. The switch in the title bar (“v6 live” | “v7”) flips between them; scroll or move in the app and both follow. Where the app lets me see it, I list what is new or gone on screen, such as a new filter or a removed tab. You can compare a version that waits to go live and the version before the live one.
- Make it live or Discard for a version that waits beside the live one. Both read the same live data; the waiting one only reads it. If the app has tests, Make it live waits until they pass.
- Restore brings an older version back after you confirm, code and data together.
When a new version waits, I also tell you in the chat, with Make it live and Compare right on my message. It is the same decision as in the app, with the same rules: only people who may change the app, and only once its tests pass.
Who may ask for changes depends on the app’s sharing level: you alone for Mine, anyone on the team for Team. People from other teams send the owners a request instead.
Data dashboards
A dashboard that shows data from your systems, for example pipeline state, test stages and the last full e2e run per repository, is an app with its own data store and a habit that fills it.
- I work out once, with read-only access to your code host and connections, where the numbers come from, and write that down as a recipe.
- A habit runs the recipe on your team’s runner on the schedule you chose, without a model call each time, and writes the rows into the app. The data stays on your runner.
- When a recipe stops fitting, say a job was renamed or a stage removed, the habit notices the empty or stale columns and I repair the recipe.
You find the habit on the team’s Automations tab, where you can pause it or change how often it runs.
Dashboards of your Jira projects
A dashboard can also count the work in your Jira projects, not only look up single issues. Ask for what you want to see, for example “open items by status”, “what sits in review”, “done per week”, “the oldest open bug” or “the median cycle time this quarter”, and name the project.
- Rows can be the project, its status categories, issue types, assignees, sprints or the last weeks. Each column is a count, story points, items created or done in a window, the oldest open item, the last change, a cycle time, or a split by status, type or assignee.
- I first look at the project the way it is set up: its own status names, types and labels. When your team calls its review status “Code Review”, the column counts “Code Review”.
- Every refresh also keeps a dated copy of each row, so the app can draw how the numbers move over weeks and months.
- I only count what kanman may read for your team. The projects, issue types, labels and security levels your admin set for the Jira connection apply to every refresh; items outside them are never read into the dashboard. Ask for a project your team cannot see, and I tell you which ones it can.
- When your team renames a status a column counts, the column stops matching. I notice that on the next refresh and repair the column.
Jira is the first tracker this works with. For issues in GitLab or GitHub, I offer a table of your repositories or answer in the chat instead.
Dashboards of your monitoring
A dashboard can also show what your Grafana knows, one row per repository, connector or service. Point me at a panel or describe a query, say which label names the rows, and say what you want to see: “the error rate per repository now”, “the slowest connector this week”, “error log lines per service today”.
- Each column is the value now, the minimum, maximum or average over the range, or the log lines of the row: how many, how many at error level, and when the newest came in.
- I first look at the panel or query the way it is: the labels its series carry and the values of the one you name. When your team’s label is called
repositoryand notrepo, the rows followrepository. - Log lines are counted for every team. The newest line itself only shows when your team allows log lines in its monitoring settings; without that, I leave the column out and tell you why.
- A dashboard shows up to 60 rows and reads a week of metrics or a day of logs at most. When there are more values, I tell you while I build it.
- Every refresh also keeps a dated copy of each row, so the app can draw how the values move over time.
- When the label stops matching (a renamed label, a changed query), the rows go empty. I notice that on the next refresh and repair the dashboard.
Dashboards of your code quality and vulnerabilities
A dashboard can show, per repository of your team, what SonarQube or Dependency-Track found: “the quality gate and open critical issues of our connectors”, “vulnerabilities by severity per service”.
- Each row is one of your team’s repositories. Columns can be the quality gate (SonarQube), the open findings (all, or only some severities), a split by severity, the newest open finding (SonarQube), the last SBOM import (Dependency-Track) and the project itself.
- Which project belongs to which repository comes from your team’s mapping. When a repository has none, I look for a project with the same name and ask you before I use it: one question that names the pairs I found. A project that only looks similar, I never pick on my own.
- Until a repository has a confirmed project, its row says unmapped. For Dependency-Track I propose the pairs for a lead of your team to confirm; until then the row says proposed.
- A dashboard shows up to 60 repositories; when your selection has more, I tell you while I build it.
- Every refresh also keeps a dated copy of each row, so the app can draw how the numbers move.
- When projects move (new keys on the server), their rows stop filling. I notice that on the next refresh and ask you before I follow the new keys.
Dashboards of your incidents
A dashboard can count the ServiceNow incidents of what your team looks after: “open P1 and P2 incidents per service”, “resolved this week per group”, “the oldest open incident per CI”.
- Each row is one of the assignment groups, business services or configuration items your team’s ServiceNow feed maps (Team settings > Services and on-call). Incidents that none of them names never count.
- Columns can be the open incidents, the ones opened or resolved in a window (up to 90 days), the newest and the oldest open incident, a split of the open ones by priority, and the median time to resolve. Any column can be narrowed to some priorities.
- I read only what kanman’s ServiceNow user may see, and only numbers, times and links: no ticket text and no names.
- A refresh reads up to 2,000 incidents (the newest first); a team with more sees counts that stop there.
- Every refresh also keeps a dated copy of each row, so the app can draw how the numbers move.
- When ServiceNow stops answering (for example because kanman’s user lost its rights), I notice it on the next refresh and tell you what an admin needs to check.
Dashboards of your Confluence pages
A dashboard can show what your documentation covers: “does every connector have a runbook, and is it stale?”, “pages per space with the last update”, “the newest page per label”.
- Rows can be the spaces you name, the labels their pages carry, the pages themselves, or your team’s repositories: a page belongs to a repository when its title or one of its labels names the repository. Name a label (for example
runbook) to look only at those pages. - Columns can be the number of pages, the newest and the oldest update, how many pages are stale (not updated for a number of days you choose, 180 by default), whether a page exists, and the newest page with its link.
- I only read the spaces kanman may read for your team, and pages with view restrictions (or below a restricted page) stay out; ask for another space and I tell you which ones you can use.
- A refresh reads up to 2,000 pages.
- Every refresh also keeps a dated copy of each row, so the app can draw how your documentation keeps up.
- When your team renames the label a dashboard counts, the rows go empty. I notice that on the next refresh and repair the dashboard with the new label.
Where an app’s data comes from
Every app I build gets its data one way by default: a table in the app’s own store on your team’s runner, kept current by a habit. Each thing the app shows has its own table.
| Way | What it is for | What you notice |
|---|---|---|
| A table I keep current (default) | Everything the team looks at together: pipelines, Jira counts, incidents, findings, pages | A habit refreshes it on your runner on the schedule you chose. When a connected system is down, the app keeps showing the last rows. |
| A live lookup | Something one person looks up with their own rights: a detail they open, a search | Each person gets only what their own rights allow, at the moment they ask. |
| Inside the app | Fixed reference data only, such as labels or a mapping of codes to names | Small and never changing. A copy of changing data inside an app goes stale, so I refuse it and put the data into a table instead. |
When you ask me to change an older app that still carries a copy of its data, I move that data into a table as part of the change.
Apps open instantly
When you open an app you opened before, it shows the way you last saw it right away, while the live app starts on your runner. As soon as the live app has loaded its data, it fades in over your last view. There is no “Starting the app…” in between.
- What you see first is your own last view, kept only in your browser on this device. Others who use the same device never see it, and signing out removes it.
- It only shows while you may still open the app and your access to it has not changed since. After a week it is no longer shown.
- If you are in another team and the app shows you data through your own connections, you first see only the layout of your last view, without data, until the live app is up.
- The first view is a picture: buttons and filters work once the live app has taken over, a moment later.
Related
Last updated: January 1, 0001
Open kanman