1 files changed, 63 insertions, 0 deletions
diff --git a/sifterapp/complete/issue-tracking-challenges.txt b/sifterapp/complete/issue-tracking-challenges.txt
new file mode 100644
index 0000000..fc5e03e
--- /dev/null
+++ b/sifterapp/complete/issue-tracking-challenges.txt
@@ -0,0 +1,63 @@
+Tracking issues isn't easy. It's tough to find them, tough to keep them updated and accurate, and tougher still to actually resolve them.
+
+There are quite a few challenges that can weigh down a good issue tracking process, but fortunately there are some simple fixes for each. Here are a few we've discovered over the years and some ways to solve them.
+
+# Lack of participation.
+
+The most basic problem is getting your team to actually use the software. Participation and collaboration are the cornerstones of a good issue tracking process, but that collaboration and teamwork runs smoothest when everyone is using the same system. 
+
+If everyone is not working together the process will fall apart before you even get started.
+
+If your team is using email or littering their desks with sticky notes that's a pretty sure sign you have a problem.
+
+Solution: Get everyone using the same system and make sure everyone is comfortable with it. 
+
+# Too difficult to report issues.
+
+If it's too hard to actually report an issue, for example, if there are too many required, but irrelevant fields in your forms, or it's too hard to upload relevant files, or it's just too difficult to login and find the "new issue" link, then no one will ever report issues in the first place. And unreported issues are unsolved issues.
+
+Solution: Keep your forms simple, offer drag-and-drop file uploading, and, if all else fails, email integration.
+
+# Too difficult to find issues.
+
+If you can't find an issue, you can't fix it. 
+
+Typically the inability to find what you're looking for is the result of weak or minimal searching and filtering tools in your issue tracker. 
+
+Sorting and filtering needs to be powerful and yet simple. Overcomplicating these tools can mean you'll accidentally filter out half of your relevant issues and not even realize it.
+
+Solution: Simplify the process of searching, filtering and finding issues. 
+
+# Over-engineering the process.
+
+The best way to avoid over-engineering anything is to keep things as simple as possible. For example, try to solve your problems with your existing tools before you create new tools. 
+
+One example of this we've discovered is having [too many possible statuses](https://sifterapp.com/blog/2012/08/the-challenges-with-custom-statuses/) for an issue.
+
+Keeping things simple -- we have three choices, "On Hold", "Assigned", and "Accepted" -- avoids both the paradox of choice and any overlap. If you have ten possibilities (or worse, completely custom statuses) you've added mental overhead to the process of choosing one. Keeping it simple means you don't have to waste time picking a status for a given issue. 
+
+Too many statuses creates crevices for issues to hide in and be forgotten when filtering issues. Overly detailed statuses can also confuse non-technical people who will wonder, "what's the difference between accepted and in progress?" Good question. Avoid it by making statuses clear and simple.
+
+There are also clear, hard lines between each of these three statuses and no questions about what they mean.
+
+A related problem, and the reason some teams will clamor of more status possibilities, is the tendency to conflate statuses with resolutions. For example, "working as designed" isn't a status; it's a resolution. Similarly, "can't reproduce" isn't a status; it's a resolution.
+
+Solution: Keep your status options simple and focus on truly different states of work with clear lines between them.
+
+
+# Over-reliance on software for process.
+
+Software is a tool. Tools are wielded by people. The tool alone can only do so much. Without people to guide them even the best of tools will fail. 
+
+That's why you need to make people the most important part of your issue process. 
+
+Make room for the human aspects of issue tracking, like regular testing sessions, consistent iteration and release cycles, and dedicated time for fixing bugs.
+
+Solution: Invest time and effort in the human processes that will pair with
+and support the software.
+
+# Conclusion
+
+Tracking issues isn't always easy, but you can make it easier by simplifying. 
+
+Cut out the cruft. Make sure you have good software and good processes that help your team wield that software effectively. Let the software do the things software is good at and let your team fill in the parts of the process that people are good at.