BugTracker is a user-friendly application that I developed using Java and JavaScript and popular web frameworks and libraries such as Spring and React. It serves as a simplified version of Jira and is ideal for projects that don't require the flexibility of Jira but still want an efficient way to keep track of their bugs, issues, and features.
One of the best things about BugTracker is its scalability. If your project expands in complexity and you find yourself needing more advanced features, you can easily transition to Jira with a simple click. All of your bugs, issues, and features will be transferred to your Jira account.
I've tried to implemented best practices in security to ensure a secure connection between you, the server, and your Jira account using JWT. Additionally, the front-end uses Redux for state management, including undo/redo and theme toggle features.
The entire system is deployed on AWS using various services such as ElasticBeanstalk, DynamoDB, RDS, and Lambda, ensuring maximum reliability and scalability for the project.
Access the application through http://localhost:3000
pouria -zsh — 104×5
➜bug-trackergit:(master)|
Inspiration
When I was on a project for one of my university courses, my team and I chose Jira as our bug tracking tool for the project. At first, we were exited to use a professional tool like Jira, but soon we realized that it was too complicated for our needs. We didn't need all the advanced functionalities that Jira offers, and it was overwhelming for us to navigate through the interface and find the features that we needed.
As a result, I found myself spending more time trying to figure out how to use Jira than actually using it to track our bugs and issues. I realized that there must be a simpler solution for bug tracking that doesn't require extensive knowledge of complex tools.
That's when I got the idea to create BugTracker, a simplified version of Jira that offers only the functionalities that are essential for small to medium-sized projects.The motivation behind creating BugTracker was to provide a simple and intuitive bug tracking tool that can be easily used by anyone, regardless of their technical knowledge. I wanted to eliminate the frustration and time wasted on trying to figure out how to use a complex tool like Jira, and instead provide a tool that is straightforward and easy to use.
Challenges
User authentication state management
The most challenging part of the development was related to the automatic scalability feature of Elastic Beanstalk. When the traffic to the application reduced, Elastic Beanstalk automatically destroyed instances, which in turn destroyed the user authentication state. This was a significant issue as it would have negatively impacted the user experience, forcing them to log in again each time an instance was destroyed.
To address this challenge, I decided to implement a solution that involved saving the user's authentication state on AWS DynamoDB for persistence. To achieve this, I used AWS Lambda as the function that saved the user authentication data on DynamoDB. This solution not only addressed the challenge of user inconvenience caused by instance destruction but also improved the overall user experience of the application.
Synchronization between BugTracker and Jira
As I was working on integrating the BugTracker app with Jira, I came across a major challenge - making the two applications asynchronous. The goal was to ensure that any updates made in BugTracker were immediately reflected in Jira, and vice versa, without any lag or delays. Initially, I tried using a simple REST API call to transfer data between the two applications. However, this approach was not effective as it resulted in significant delays and even data loss in some cases.
After some research, I realized that the best approach to make the integration asynchronous was to use webhooks. Webhooks allow for real-time communication between two applications and can trigger immediate updates whenever a change is made in one application.
To implement this solution, I used the Jira REST API to create a webhook in Jira. Whenever an issue was created, updated, or deleted in BugTracker, the webhook would be triggered, and the relevant data would be sent to Jira in real-time. Similarly, any changes made in Jira were also immediately reflected in BugTracker through the same webhook.
Future ideas & what’s next
Looking ahead, there are a few features that could be added to the project to further improve its functionality. One potential area of expansion would be to add more integrations with popular development tools such as GitHub or GitLab. This would allow users to connect their repositories with BugTracker and track issues and bugs directly from their development environment.
Another potential area of expansion could be to add more advanced reporting and analytics capabilities to the project. This would enable teams to gain more insight into their development process and identify areas where improvements can be made. Additionally, adding collaboration features such as commenting and task assignments would further enhance the usability of the platform.
