At Prominent, we pride ourselves on how we differ from many other software development companies. One such difference is our desire for constant improvement, which is apparent throughout our Software Development Life Cycle (SDLC).

One of the most important aspects of developing quality software is having a solid and flexible SDLC methodology in place. This methodology is the backbone of how we build software; it removes the typical pitfalls of software development projects and allows us to constantly improve, better serving our customers.

Read more about how our SDLC brings unique value as we strive to “hit the bullseye” for our customers.

A Customer-First SDLC

We have designed our SDLC to be an iterative process that allows us to course-correct early and often so we can always put the client first, while still keeping our eyes on the final outcome. We have specifically baked a few elements into our SLDC to ensure adaptability in our process:

  • At the end of every “sprint,” we hold a retrospective during which we discuss what went well and what did not, along with any changes we want to make to the process.

  • At the end of every project, we hold a retrospective during which we discuss the entirety of the project and define any changes we want to make for the next project or to our process as a whole.

  • We only track the metrics that matter, so that we can better define our estimates and provide ourselves with an accurate forecast of schedule and budget.

The Beginning: Solution Roadmapping

Our SDLC technically begins when a potential client approaches us with a problem, whether it’s a currently unmet need or a desire to improve a business process. We have assembled a team that includes Project Managers (PMs), Business Analysts (BAs), Architects, and Executive Advisors who will conduct an assessment for solution roadmapping. The assessment includes, but is not limited to, learning about the client’s current state as well as their requirements for solutions.

We always provide several options for our clients, offering recommendations and various paths forward that empower the client to make the decision that best meets their needs.

A unique part of this process is that our “Solution Roadmapping” results are available for clients whether they ultimately decide to have us develop a custom solution or not. These options often include a recommendation to use an existing out-of-the-box solution, proceed with custom development or even to go with another third-party company that we feel would best serve our client’s needs. Ultimately, we just want to empower our customers to do what is best for them.

If the client chooses the option that involves Prominent developing a custom solution, we will move into our SDLC.

The Stages of our SDLC

Our SDLC is the time when the major development of project work occurs. At Prominent, we follow an agile methodology which is largely based on Scrum. It really boils down to three key tenants: we listen, we care and we work with the customer to ensure that what we build will positively impact our customer’s bottom-line. We acknowledge that we may have to adapt and accept it as a pillar of developing good software.

Our software development lifecycle at Prominent

Our unique SDLC comes from combining the best features of various methodologies, making them iterative in nature. The stages of our SDLC are:

  1. Planning
  2. Designing
  3. Developing
  4. Testing
  5. Deploying and Maintaining

The designing, developing, testing, and deploying happen iteratively - typically every two weeks.


Our BAs gather requirements from Subject Matter Experts (SMEs) in the Planning phase. Our BAs try not to let the customer’s current solutions influence them. However, the BAs use the current solutions as a benchmark to ensure that whatever we build is better than what was there before.

This process typically begins with Solution Roadmapping, during which the BAs work directly with the customer over a period of time to understand the goals, user stories, and requirements–prioritizing our customer’s values. This process could range from one day to even a month or more, however long it takes to document the high-level features needed and to define the Minimum Viable Product, or MVP. This is the minimum feature set that can be built while still providing value to the customer. Defining the MVP is one of the most important steps in a successful project because we need to ensure timing won’t render the project obsolete before it goes live. Instead, we try to define the smallest necessary solution that will solve the most pressing needs and get it into the user’s hands early. This allows us to quickly detect pain points, ensuring that we can resolve them immediately and avoid having to re-work something in the future.


Then, our User Interface and User Experience (UI/UX) team works with the client to design wireframes to scope out what we will build in the Designing phase. Our team of experts builds wireframes for the client to review and comment on. The SMEs will also review what we have created to ensure that it solves any issues and that it is intuitive and simple to use. If it needs to be mobile-friendly (and let’s be honest, in 2020, that’s almost everything), our team will design wireframes for that as well.

Once approved, we pass these wireframes and requirements on to the development team to turn into functioning software.


Next, the development team codes the software during the Developing phase. Using the requirements and wireframes that we have created, the developers architect and develop the software to meet the client’s needs. At least one other developer will review all code written, and the Project Managers will monitor the entire process from start to finish to ensure that scope, schedule and budget are under control.


Hand-in-hand with the developers is the Quality Assurance team, testing the software in the Testing phase. After the code has been reviewed, it is deployed into the test environment where QA specialists exercise the software, taking it through all documented use cases and verifying that it meets all the customer’s requirements. They go beyond that as well, making sure it functions in a way that makes sense, is easy to use and performs well in all scenarios.

Once they’ve verified the functionality matches the requirements, the QA team demos the software to customer stakeholders, subject matter experts and the Product Owner (PO), so they can receive early feedback, and we can immediately make any adjustments necessary. Once we make any changes from the demo, we gather the minds of the customer (SMEs and PO) for the User Acceptance Testing (UAT). During the UAT, they will use the software and verify that it solves the client’s needs.

Deploying and Maintenance

The final stage of our SDLC is the Deploying and Maintenance phase. The software is deployed into the production environment where the customer can use it. During this phase, we will quickly resolve any issues, and following this, the software moves into Maintenance, during which we add any features that didn’t make MVP or that the client discovered during Deployment.

Tuning our SDLC

While our SDLC is made up of phases, the phases are not linear. That is, the Analysis phase is not 100 percent complete before the Design phase starts. Solution Roadmapping (which is optional, though highly recommended) happens before the kickoff of actual development, but once development starts, we use the agile methodology to iterate constantly, adapting to change and listening to our customers to always bring it closer to the target.

Throughout the development process, the BAs and UI designers meet with the SMEs to refine and flesh out the requirements and wireframes to a final form, and the developers can start work without worrying about what’s coming down the pipe.

As the developers complete features, the QA team tests them and provides the developers with immediate feedback to tune the software, removing bugs and ensuring it’s growing into what it needs to be. QA demos it, providing the client opportunity to provide early feedback, and the client gets to UAT the product so everybody can be confident that it functions as necessary.

We tune our SDLC from beginning to end to ensure that we are providing the best value for an affordable cost. We are constantly striving to maximize the benefits of the software we develop for our clients while maintaining a process that allows us to hit the mark with each and every client.

Daniel Bickler
I have over seven years of experience developing software that utilizes various technologies, including Java, C# and Javascript. I’ve worked on everything from large enterprise projects containing millions of lines of code and hundreds of developers to small, greenfield projects where I’m the sole developer creating something from scratch for a client. I joined Prominent in 2017 and have been involved with many of the custom solutions developed since then, working as a developer and an architect. As an architect, my main goal is to make sure that software architecture is constructed correctly and efficiently, ensuring a better product for our clients.