Devlog

Asynchronous informal logging of developer's day to augment development tracking and team collaboration.

Comment

Inspiration

Daily standups are meant to surface progress, blockers, and context—but in reality, most valuable information still lives only in developers’ heads.

Throughout a typical day, developers think and do things that are important to teammates but feel too informal, too early, or too incomplete to put into Jira comments:

  • “I explored two approaches but neither feels right yet.”
  • “I’m waiting on a schema clarification before pushing.”
  • “I switched from Ticket A to Ticket B because a dependency broke.”
  • “This part is trickier than expected; might spill into tomorrow.”

None of this usually gets recorded. Jira comments tend to capture finalized outcomes, not work-in-progress context. As a result, teams rely on synchronous standups, DMs, or constant follow-ups to understand what’s really going on. This doesn’t scale, breaks focus, and penalizes distributed teams.

We asked a simple question: What if the standup meeting didn’t need to be a meeting at all?

That became the core idea behind DevLog—an AI-powered, asynchronous standup replacement that captures the informal, in-between signals of development and makes them visible when and where they’re needed.

What it does

DevLog allows developers to asynchronously log their day in a lightweight, natural way—without meetings, pings, or forced updates.

Developers can record four types of short textual logs, each linked to relevant Jira issues:

  • Day Start – “Planning to refactor the ingestion logic for ENG-421; unsure about memory impact.”
  • Day Mid – “Refactor mostly done, but blocked on missing event schema from analytics.”
  • Day End – “Core logic merged, tests pending; will finish tomorrow.”
  • Day Misc – “Explored an alternative approach; parking it for now.”

These are exactly the kinds of updates that never make it into Jira comments—but are incredibly valuable for teammates and PMs.

The logs can be:

  • Viewed directly in a Forge-based frontend inside Atlassian
  • Queried intelligently via an Atlassian Rovo Agent

Examples:

  • A PM can ask: “What did Jason work on today? Did he encounter any blockers?”
  • A developer can ask: “Is Tom close to pushing the engagement analytics pipeline? I need that data by the 28th.”

DevLog turns scattered, informal thoughts into shared team awareness, without requiring everyone to be present at the same time.

How we built it

DevLog is built entirely on Atlassian Forge, using only Atlassian-native infrastructure.

  • Forge UI for the developer-facing logging and viewing experience
  • Jira integration to associate logs with real work items
  • Atlassian-hosted compute for all application logic
  • Atlassian SQL database storage for securely persisting daily logs
  • Rovo Agent integration for natural-language querying over logs

There are no external APIs, services, or databases. All compute and data storage remain within Atlassian’s platform, making DevLog secure, compliant, and enterprise-ready by default.

The data model is intentionally structured enough for AI querying, while remaining flexible so logging never feels like reporting overhead.

Challenges we ran into

The hardest challenge was designing something that developers would actually use consistently. Daily standups work not because they are efficient, but because they are socially enforced. An asynchronous system has no such pressure—so DevLog had to be lighter than a meeting and easier than writing a Jira comment, otherwise it would fail by default.

Another challenge was capturing information that is useful but intentionally informal. The exact things DevLog is meant to surface—half-formed thoughts, early blockers, uncertainty, context switching—are also things developers are hesitant to record if the system feels permanent or evaluative. We had to be deliberate about log types, tone, and placement so DevLog feels like a personal development log first, and a team signal second.

We also faced the challenge of making AI queries genuinely actionable. Simply summarizing text is not enough; teammates and PMs ask dependency and readiness questions (“Is this close?”, “Is someone blocked?”, “Can I plan around this?”). Structuring logs so a Rovo Agent can answer these questions accurately—without over-structuring developer input—required careful iteration.

Finally, we had to ensure DevLog enhances Jira rather than diluting it. Jira is optimized for decisions and outcomes; DevLog is optimized for work-in-progress reality. Maintaining that boundary was essential to avoid duplication and adoption fatigue.

Accomplishments we’re proud of

  • Creating an asynchronous standup replacement that doesn’t interrupt focus
  • Capturing work-in-progress context that never reaches Jira comments
  • Building a fully Atlassian-native app with no external dependencies
  • Seamlessly integrating Forge, Jira, SQL storage, and Rovo Agents
  • Enabling teams to ask natural questions instead of chasing updates

What we learned

We learned that the most valuable development information is often the least formal. When teams have access to that context asynchronously, collaboration improves without additional meetings or pressure.

We also learned that AI agents shine when paired with human, day-to-day context—not just tickets and documentation. DevLog turns everyday developer thoughts into accessible team knowledge.

What’s next for DevLog

Next, we plan to:

  • Generate automatic daily and sprint summaries
  • Surface dependency and blocker signals across teams
  • Add opt-in productivity insights without micromanagement
  • Extend visibility into Confluence and Slack, while keeping Forge at the core

DevLog’s goal is simple: Replace standups with shared context—captured naturally, surfaced intelligently, and accessed asynchronously.

Built With

Share this project:

Updates