PROJECT MANAGEMENT PROCESSES

Optimizing Git Tickets For Better Development Projects

Unlock the secret to turbocharging your project's development journey with Git. Discover how strategic ticketing transforms chaos into clarity, driving unparalleled efficiency and success.

The importance of meticulously crafted Git tickets is often underestimated in speeding up website development and deployment processes. Effective ticketing plays a pivotal role in project management, ensuring clarity, accountability, and seamless collaboration among team members.

Pain Points of Poor Ticketing

Unclear expectations lead to rework

Improperly written tickets have been one of the core pain points addressed by both clients and developers during development. A lack of clarity during the ticket writing process often leads to misinterpretation of requirements. Developers may implement features or fixes incorrectly, deviating from the client's expectations. This results in rework and wasted time. 

Scope creep

Poor ticketing process can also lead to incomplete scope or even scope creep. Developers may struggle to understand the full scope of work, leading to incomplete implementations. Clients might receive deliverables that don't meet their expectations or fail to address all required functionalities. Alternatively, there can be cases where the task deviates from the original scope, and more deliverables mount up for a task that might have started as a small feature addition. 

Introduction of bugs and errors

Poorly defined tickets increase the likelihood of introducing bugs, errors, or inconsistencies in the codebase and this affects the overall quality of the deliverables. Furthermore, unclear tickets hinder effective communication between clients and developers. Clients may struggle to convey their requirements accurately, while developers may find it challenging to seek clarification or provide progress updates. These issues completely break down communication. Without clear guidance, developers may spend additional time going back and forth to make more sense of the task or making assumptions about the requirements. All of this just culminates in delays in development, increased costs, and ultimately, frustration and discontent for all parties involved.

Consequently, at Acro, we’ve consistently made an effort to address this challenge and have laid out processes to clearly capture and define the requirements on every ticket that we create.

Optimizing Tickets Effectively

Now that we have defined what happens with poor ticketing let’s delve into strategies and examples for writing better Git tickets to capture all technical requirements comprehensively. Proper, clear ticket writing will streamline your website's go-to-market strategy. The following are some important key points to keep in mind when articulating a ticket.

Establish clear objectives

Begin by defining the primary objectives of the Git ticket. Clearly articulate the problem or task at hand, along with its significance in the broader context of the project. This sets the foundation for understanding the technical requirements necessary for implementation. The objective doesn’t need to be extra long, it can be just a couple of sentences of the overall goal the client wants to achieve.

Provide detailed context

Contextual information is essential for developers to grasp the purpose and scope of the ticket. Include background details, user stories, or relevant documentation to offer a comprehensive understanding of the issue or feature being addressed. This ensures that developers have the necessary context to make informed decisions during implementation. We always ensure that when writing the details for the ticket, any developer from any project can just walk in and start on the ticket without needing to ask for more clarification.

Specify functional requirements

Outline the specific functionalities or behaviours expected from the implementation. Use clear and concise language to describe the desired behaviour, inputs, outputs, and any acceptance criteria that must be met for successful completion.

Always break down complex tasks into smaller, manageable subtasks, each representing a distinct functional requirement. A general rule of thumb at Acro is that no ticket should be larger than a 5 in terms of story points. Anything larger than that should be broken down into smaller tickets so that it’s easier to manage and implement for both developers and clients.

Story Points	Complexity & Effort
0	No effort. Used for tracking purposes only.
1	Very low effort/complexity. Could do multiple of these in 1 business day.  Does not require a code push or QA. Examples are pulling a report, answering a question, and copying a change in config.
2	Very low. Could get multiple of these to their Definition of Done (DoD) in a day.
3	Low. Likely meets DoD in 1 – 2 business days.
5	Medium. Likely meet DoD in 2 – 3 business days.
8	Medium. Up to 1/2 a sprint for a single developer.  Unknowns are getting high with an 8. If it can be broken down, it should be.
13*	High effort and complexity. Roughly 1/2 sprint or more for a single developer.  Many unknowns and risks to completion. It should be broken down into smaller pieces.
21	High effort and complexity. 1 developer's effort for an entire sprint.  Many unknowns and risks to completion. It should always be broken down into smaller pieces.

Define technical requirements

Detail the technical specifications, constraints, and dependencies associated with the ticket. This may include compatibility requirements, performance considerations, integration points with other systems, or any architectural guidelines that need to be followed. Provide references to relevant documentation, APIs, or external resources to facilitate implementation.

Include design mockups or wireframes

Visual aids such as design mockups or wireframes can significantly enhance the clarity of Git tickets, especially for front-end tasks. Attach screenshots, sketches, or links to design prototypes that illustrate the expected user interface layout, interactions, and visual styling. 

This helps align the development efforts with the desired design aesthetics and user experience.

Anticipate edge cases and exceptions

Account for potential edge cases, error scenarios, or exceptional conditions that may arise during implementation. Clearly document these scenarios along with their expected behaviours and error-handling mechanisms. This proactive approach minimizes the risk of overlooking critical edge cases and ensures robustness in the final solution.

Foster collaborative feedback

Solicit team members' input on the ticket description and requirements to encourage collaboration and feedback. Leverage Git's collaborative features, such as comments, mentions, or inline discussions, to facilitate communication and clarification. Incorporate relevant feedback to refine and enrich the ticket details, fostering a collective understanding among team members.

So, before starting on a ticket, ensure that all parties are on board with the task objectives and method of implementation. Going through each ticket during sprint planning meetings with the clients and developers on hand generally helps expedite this process and ensures that everyone is on the same page.

Using Ticket Templates for Consistency

The easiest way to capture all of this in a ticket is to start with an issue template. Numerous templates can be used as a foundation for creating tickets. Once the foundation is laid, the template can be further altered depending on the project and the type of issue being created, e.g., bug, Feature, etc. 

I generally use the following principles when writing the details for tickets:

• Adding bullet points instead of writing long sentences and paragraphs
• Structuring the bullet points in a hierarchy for better organization
• Bolding/colouring the important points
• Adding images/screencasts of the problem
• Adding wireframes/images to better capture how the end product might look like

By following these strategies for writing better Git tickets, you can effectively capture all the details and technical requirements necessary for expediting your website's go-to-market strategy. Sure, writing comprehensive tickets will take some considerable effort, but in the end, it is so worth it. Clear objectives, detailed context, comprehensive functional and technical requirements, visual aids, consideration of edge cases, and collaborative feedback are essential elements in crafting Git tickets that streamline development processes and ensure successful project outcomes.

Our Agile-backed processes improve development project outcomes.
Visit our website to learn how, or contact us below.