Many business leaders are hesitant to develop a custom application. They’ve experienced failed software development projects or heard horror stories: projects that come in months late and outrageously over budget. Project scope that changes and grows over time as different stakeholders weigh in with different needs. An application that costs way too much only to be so complicated that few in the organization actually know how to use it.
There are many ways to prevent these outcomes during the software development process, but one of the biggest ways businesses can set themselves up for success happens before the process even starts.
What is a Software Development Plan?
A software planning engagement involves several steps:
- An in-depth assessment of your current needs and business problems, as well as any solutions you’ve already tried and/or the software you’re currently using
- An expert-led strategy that seeks to solve the business problems from a software perspective
- A cursory design of what the proposed solution will look like and how it will be structured and built
- A roadmap for execution that allows the partner to make the best estimate for the project’s duration and cost.
Engaging in a software development plan with your potential future development partner can help set the stage for a successful application and is the perfect first step in a potential long-term relationship.
Some firms bundle the software development plan into the actual development process or give it short shrift in the interest of making a sale, saving the hard work for after the development contract has been signed.
At MercuryWorks, we take a different approach. Potential software development projects of a certain size and importance are preceded by an initial, upfront planning engagement that is separate from the subsequent development. This arrangement ensures that the proper time and attention is given to dive deeper into each client’s business problem and propose the best solution—and if the client would like to engage with us to execute on that solution, they can.
Here’s why it works and why we recommend it.
Why Software Development Needs a Strategic Plan and Roadmap
It allows for more accurate estimates regarding
At MercuryWorks, it’s rare that a potential customer comes to us who does not have at least a “back-of-the-napkin” idea or some basic goals for a new application. They have a general idea, and along with that general idea they have two main questions:
- How long will the application take to build?
- How much will it cost
These are good and simple questions, but they require more information and a deeper understanding of the problem space to be answered with any level of accuracy and integrity.
While a software development partner might be able to offer a very broad range of time and budget estimates after a few discovery calls, it’s impossible to make a solid development plan with specific technical recommendations based on such limited information. Furthermore, attempting to build a detailed software development plan at this stage with only partial information would be doing the business a tremendous disservice.
A strategy and planning engagement takes a step back and surfaces all of the decisions and details that need to go into the application development process. It asks and answers two different questions:
- What problem is the business is trying to solve?
- How can that problem best be solved from a software development standpoint?
The answers to those questions make the typical questions around budget and timeframe much easier to answer because the development partner has taken the time to research and understand the problem, understand the full set of user needs, identify the right technologies to address the problem, and think through what is needed to support those technologies.
Any estimates at the end of the engagement aren’t shots in the dark: they’re deliverables based on facts, research, and the development team’s expertise.
A development plan creates clarity of vision between the development team and the client.
Unlike a general development proposal that follows a discovery call or two, a software strategy and planning engagement isn’t built on gut instinct and limited information. It outlines the actual business needs, recommended features and functionality, and application architecture for development, providing a detailed blueprint (with tangible deliverables) for the successful creation of the application.
But this can only happen successfully when the development partner and the client share a clear vision for the project. As the experts in the field, the development partner assumes the responsibility for bringing that vision to life by coalescing and extending the client’s thinking around the project and filling in key gaps that the client might not have considered.
By leading a collaborative planning process, the software development partner helps the client visualize and prioritize the core elements of a new application—before the actual building begins.
This type of engagement also provides the development partner with the headspace and time to dedicate to brainstorming, iteration, and feedback, thoroughly exploring the entire problem space to arrive at the best solution rather than just rushing to provide a guestimate of timeline and budget.
It aligns stakeholders and enables buy-in.
Compared to esoteric, abstract proposals that leave the details to the actual development process (and potentially introduce complexity and costly delays to the timeline), the deliverables from a software planning engagement demonstrate that the project isn’t a haphazard, poorly planned endeavor.
A good software development plan isn’t theoretical. It’s a tangible, detailed deliverable that can be shown to relevant stakeholders for approval and sign-off to enable the actual development of the application.
Having a concrete plan that articulates the vision of the project in words, illustrates its design in graphics, and diagrams the architecture of the application is key to drive organizational support from executive and IT stakeholders. The plan also anticipates common stakeholder objections and answer questions before they become sticking points.
Key Players in Software Development Strategy and Planning
A successful planning engagement involves key stakeholders on both sides of the equation. On the client side, it’s ideal to engage the decision makers and influencers who have an interest in the new software both from a functional and a financial standpoint. This includes the company’s technical and financial decision makers, along with the primary decision maker(s) for the department that will be using the software.
We find that our clients do not often have the internal technical resources that bring the experience and skillset required to formulate a vision for the product and think through that vision’s details. Or, if they do, these individuals do not have the bandwidth to focus on doing so amid their myriad day-to-day responsibilities.
At MercuryWorks, our most seasoned team members lead the core components of our assessment, strategy and development planning engagements.
Each team member brings their breadth and depth of hands-on experience in developing software, managing projects, and driving business value. They’re uniquely qualified to help guide product ideas and user needs into reality, filling in the gaps required to transform a sketch into a specific and actionable plan.
The Custom Software Development Plan Process
MercuryWorks has been consistently helping clients develop mission critical systems to more efficiently and effectively manage their business for over the past two decades. While we tailor our approach to create a unique plan to best accommodate each clients’ specific needs, this is the general process we’ve honed over the years to surface the business problem and to determine the right solutions for development.
1. Discovery and Assessment
The first step in the process centers around identifying the business problem and the vision for the new application. This phase involves planning sessions between MercuryWorks and the future application’s primary stakeholders. Both parties define goals, prioritize core features for the first working version of the software (also known as the Minimum Viable Product or MVP), and discuss long-term desires for the application.
2. Technical Architecture and Data Planning
Once goals have been clearly defined, the next step in the process is determining what technology architecture are best suited to support an application of the desired scale, client preference, and in-house resource skillsets. This is where the bulk of the technical recommendations come in and speak to the needs of the client’s IT team.
There are many questions to answer in this step:
- What are the client’s existing and preferred future technologies?
- What application integration needs exist?
- How will the application store data and enable access to it?
- What security measures should be implemented?
- Will the app be accessed via desktop, mobile, or both?
- What are the reporting and analytics needs for the application?
Once these questions have been answered, the MercuryWorks architect begins to diagram the tech stack of the application to illustrate how different components such as databases, APIs, analytics platforms, and security integrations will all work together.
3. Functional and Design Planning
This portion of the development plan gives stakeholders a tangible sense of how the application will look and feel. What will the user experience be like? How will screens be organized, and how will they flow into one another?
There are several ways to visualize the application even at this early stage of the process. MercuryWorks designers create a set of wireframes, which are visual blueprints for how different elements will be arranged on each screen and how the application will be organized. High-value pages are also treated to more detailed, high-fidelity mockups that include stylistic elements like fonts, colors, and images. We believe that a picture is worth a thousand words—and that a well-conceived diagram is priceless.
These deliverables provide visual plans and artifacts that help rapidly coalesce and advance stakeholder thinking regarding the planned application. They help make the application ideas more tangible and approachable for those concerned and are an excellent resource for organizational socialization of the planned application.
4. High-Level Development Planning and Roadmap
The final step of the strategic plan incorporates and integrates all the previous elements into a single, high-level development roadmap and implementation plan. The software development partner breaks out application epics, features, and functions that need to be built in support of the application goals. These are further broken down into user stories, which are descriptions of short development tasks that break the work into manageable chunks.
Once the needed work has been broken down, MercuryWorks and the client determine which resources (MercuryWorks or in-house) are best suited to do which components of work, understanding that client development teams often play a role. We also map out how best to effectively work together during the development process.
Once we determine who will be doing each specific component of work, we create a planned development timeline that includes the development and rollout of application features and functions over time.
Having these epics, features, and user stories defined is what allows MercuryWorks to more accurately estimate the time it will take to complete each development project—and thus, to more accurately estimate the budget. What’s more, we now provide the client with a plan, informed by specific needs and goals, that can immediately lead to development.
5. Software Development Plan Deliverables
The engagement concludes with an executive readout presentation that typically includes several different elements:
- A product assessment and core requirements overview
- Detailed diagrams of proposed technical architecture
- Visual wireframes and design mockups to help stakeholders better visualize the new application
- A detailed resource plan including epics, features, and user stories for stakeholder review and input
- Cost/benefit analyses and tradeoffs of various feature/function/technology configurations
- Clear vision of the application and plan to commence with development
Is a Software Development Plan Worth the Time?
The timeline to complete a software assessment, strategy, design, and development roadmap planning engagement varies depending on the complexity of the problem and the scale of the solution, but on average we find that the process takes approximately 4 weeks.
It might feel like this is a step backward in the process and that it introduces an inconvenient delay. But taking this preliminary step reduces the risk of the delays that come later at a much greater cost: the ones that are the result of miscommunication, scope creep, unclear vision, and poorly defined goals.
After all, you would never start building a house without a clear set of architectural blueprints and engineering plans created in advance. By building a house based upon a well vetted set of plans, you ensure the structural integrity of the building and ensure that the finished product aligns with your vision. Successful software product development is much the same.
Ultimately, we recommend that companies considering any significant custom software project work with a development partner that offers assessment, strategy, and development roadmap planning—not as part of the development project, but as a precursor to it.
Interested in planning for your next custom software development project? Learn more about how we approach strategy and planning at MercuryWorks.
Interested in Learning More?
Fill out the form below and our team will follow up shortly.
"*" indicates required fields