App ID: a38f291c-cc2d-4efa-9742-d76ac964ec17

Inspiration

I chose to look past the "Transformer obsession" and leverage the power of Long-Short-Term-Memory (LSTM) networks - the gold standard for complex time-series analysis - to bring true predictive intelligence to sprint management.

What it does

Architecture: The Pre-trained Adapter Model

I utilize an advanced transfer learning architecture to achieve high accuracy with minimal user training time.

1. Core Model (5.5 MB):

A base LSTM model is pre-trained on over 10,000 synthetic but realistic sprint histories to learn the general dependencies and patterns of agile development (e.g., how the metrics of sprint N relates to sprints N−1 through N−6).

Crucially, this dataset was structured as consecutive sequences: The training input always consisted of six consecutive sprints (to be precise: metrics derived from sprint data), and the target output was always the predicted metrics for the seventh sprint.

This sequence-based training forces the LSTM to understand how previous trends and fluctuations logically influence the immediate future, making its predictions significantly more robust than models trained on isolated sprint points.

2. User Adapter (<1 MB):

Upon installation, the app fetches and sorts the user's historical Jira sprint data. This data is used to quickly train a user-specific adapter—the final LSTM and Dense layers of the model. This adaptation step customizes the general model's understanding to the unique pace, consistency, and patterns of the specific team.

Model Architecture

class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(LSTMModel, self).__init__()
        self.lstm1 = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.lstm2 = nn.LSTM(hidden_size, hidden_size, batch_first=True)
        self.lstm3 = nn.LSTM(hidden_size, hidden_size, batch_first=True)
        self.adapter_lstm = nn.LSTM(hidden_size, 32, batch_first=True)
        self.fc1 = nn.Linear(32, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, output_size)
        self.dropout = nn.Dropout(0.2)
        self.relu = nn.ReLU()

    def forward(self, x):
        out, _ = self.lstm1(x)
        out, _ = self.lstm2(out)
        out, _ = self.lstm3(out)
        out, _ = self.adapter_lstm(out)
        out = out[:, -1, :]  # Take last time step
        out = self.dropout(out)
        out = self.relu(self.fc1(out))
        out = self.relu(self.fc2(out))
        out = self.fc3(out)
        return out

model = LSTMModel(input_size=len(features), hidden_size=256, output_size=len(target_column)).to(device)

Output: Actionable LLM Insights

Predictions are not just raw numbers. The forecast results are passed to an LLM for natural language analysis, generating actionable insights.

How I built it

Full-Stack ML Deployment:

The core LSTM logic is built in Python (PyTorch, NumPy), while custom backend orchestration is handled by Node.js.

Custom Inference Server:

Atlassian Forge functions communicate securely with a dedicated inference server. This architecture allows to combine the large pre-trained model with the lightweight user adapter efficiently.

Data Privacy:

Your Atlassian Account ID is the only personally identifying data saved, used strictly to locate your adapter weights. Raw Jira data is processed and not retained, ensuring minimal data footprint and maximum security.

Challenges I ran into

The Forge Timeout Challenge:

One significant challenge was managing the potential timeouts inherent in running complex AI inference (especially the initial model adaptation) within the strict connection limits of the Forge environment.

Solution:

Asynchronous Reliability: I implemented a robust, asynchronous architecture where inference jobs run in the background on our dedicated server. If a frontend connection times out, the job continues, and the frontend handles the retry gracefully. The user simply reloads the page to fetch the completed, persisted results, ensuring a reliable user experience even during high latency.

Accomplishments that I am proud of

The model achieved an 89% prediction accuracy on a synthetic testing dataset, validating the LSTM's strength. I am most proud of building a complex ML architecture that seamlessly integrates into the Jira UI using Forge.

What I learned

I learned about the forge environment and the possibilities within atlassian's ecosystem. It is exciting to develop in this frame.

What's next for SprintSense

The next steps for SprintSense are to implement more LLM providers (currently only OpenAI) as well as deeper analytics, more interactive charts and powerful metrics.

Built With

• express.js
• javascript
• mysql
• node.js
• python
• pytorch
• react