Learning from Failed Projects: Integrating QuickBooks with Custom Software

Custom software development is rarely a straight path, and projects don’t always go as planned. With so many variables at play—from legacy systems to third-party integrations—unexpected challenges can arise. At Adatasol, we encountered a similar scenario when attempting to integrate a client’s existing FileMaker-based inventory tracking system with QuickBooks through third-party middleware. Though the outcome wasn’t what we anticipated, the project offered valuable insights into custom software development and integration.

The Project Background: QuickBooks Integration through Middleware

Our client, who had an older, custom-built inventory tracking system, wanted to integrate QuickBooks to streamline financial reporting. This legacy system had been modified over years by multiple developers, resulting in a complex, layered structure. To bridge the inventory software with QuickBooks, the client opted for a middleware solution that we hadn’t previously worked with.

Key Challenges with the Existing Solution

1. Inconsistent Development Practices: With many hands shaping the solution over the years, consistent practices and standards were lacking, adding complexity and potential points of failure.
2. Legacy Structure: The existing system was built around a paper-based workflow, which diverged from modern inventory practices. Aligning this older, unique structure with QuickBooks’ standardized workflows posed significant challenges.
3. Middleware Learning Curve: None of our team members had experience with the middleware selected for integration, which added considerable time for research and adaptation. Not just in learning the basics, but as you actually try and implement functions you often expose nuances that either completely block the intended workflow, or require a rethinking to get around the issue.

Planning and developing the Integration: What Went Right and Wrong

Initial meetings included diverse stakeholders, including end users, management, an accountant, and our development team. We discussed needs, created a basic roadmap, and met with the middleware’s technical team to understand the product. However, despite this preparation, some issues arose:

1. Insufficient Planning: Despite discussions, our planning didn’t cover every requirement due to evolving specifications and the complexity of working with an unfamiliar third-party tool.
2. Evolving Specifications: Changes in project specifications, while sometimes inevitable, caused delays and necessitated reworking processes that had already been developed. It also lead to developing originally-unplanned features.
3. Onboarding a New Developer: A new developer joined the project, unfamiliar with both the client’s workflows and the intricacies of the legacy FileMaker system. This added to the learning curve and time spent on understanding the code structure.
4. Uncovering Unplanned Needs: During development, new requirements emerged that had not been anticipated. The need to accommodate these changes added to the complexity and timeline.

Key Takeaways: What We Learned from This Experience

While the project didn’t yield the desired outcome, it provided valuable insights that will benefit future custom software integrations. Here are some of the lessons learned:

1. Managing Expectations
Both the development team and the client must have clear, realistic expectations about the potential challenges and limitations of a project, especially when working with legacy systems or new middleware.
2. The Value of Thorough Planning and Documentation
Effective planning and comprehensive documentation can’t prevent all issues, but they can provide a clearer roadmap, helping to avoid unforeseen problems down the line.
3. Adaptability Is Essential
Custom software projects require flexibility. As new requirements and challenges arise, being adaptable is key to navigating the complexities.
4. Setting Contingencies for Unknowns
Custom integrations often involve unknowns, particularly when working with middleware and legacy systems. Establishing contingencies and anticipating these variables can help teams prepare for potential complications.

Conclusion

Not every project will succeed, but even in failure, valuable lessons can be learned. This integration project reminded us of the importance of expectation management, thorough planning, and the need to anticipate unknowns. By applying these insights, custom software developers can enhance their approach to future projects, increasing the likelihood of success—even in challenging integrations like those involving QuickBooks.