Framework & Phases of Project Management in the IT Industry

Have you noticed? Framework is on every project management job description. Everyone wants you to know how to develop software applications, but not without a framework.

So what is a framework?
Framework is the process of getting through the initiation, requirements collection, design, implementation, testing and deployment stages of a project to produce an application or service.

So, why do you need to understand Framework?

Understanding of Framework makes the process of project management efficient. But there’s a real problem here, with so many different project management approaches, the framework is confusing.

We will give you more clarity on this topic that you will find in every project phase to build a framework for managing the project.
Let’s get started!

Why Do You Need a Project Framework ?

We want to point four basic mindset that a PM needs for organizing a project into Framework:

● Clear goal & Clear scope/requirement
● Highest Efficiency & Lowest Risk
● Great teamwork
● High adaptability

Next comes some common framework phases in software development:

1. Project Initiation
2. Concept Development
3. Planning
4. Requirements Definition
5. Design
6. Development
7. Integration
8. Testing
9. Deployment
10. Maintenance
11. Hand-off, Closure, Support

Project Framework Phases vs Project Management Process
There’s a bit of confusion here.
You see, Project Management Process is described by five approach groups:

1. Initiation
2. Planning
3. Execution
4. Monitoring and Controlling
5. Closure

Each phase, if it’s big enough, can run through all these process groups.
However, if a project is small process groups can coincide with phases.
Or a process group will cover several phases at once.
Likewise, on tiny projects, there’ll be only one phase at all.

Imagine as if You Have all the Framework Phases. Some of you may think that you don’t have all these phases. Therefore, it feels like you have only one distinctive phase. Or an agile environment, and you perceive as if your project starts with the Sprint 1.

However, here’s what we suggest:

And each framework has its exit criteria. For example, something you need to create or achieve to move forward.

Most phases – you can close immediately because you have predefined processes and tools.
Some of the phases will stack one upon another, and you’ll grind through them in iterations.
And there’ll be phases where you do not participate.
But they do exist.
So, people impact your project there.
Now we’ll review each possible phase of the framework.

Let’s dig into each one

1. Project Initiation phase

After the contract is signed, you get into the initiation framework.
Here you need to define what’s the goal of a project, and it’s success criteria.
Even if you are under Times and Materials contract it’s vital to get through this framework.
Therefore, you need to create a Project Charter. At least you need to define the key information that it has.

You’ll need a lot of input on many aspects of software development:
● User Interface
● User Experience
● Technical limitations
● Hardware specifics
● Development environment
● Software architecture

Therefore, don’t expect to get all the details from your clients and customers. You’ll need to include internal expertise.
Once you have a glimpse of the project and its goals you can continue to the next framework.

2. Concept Development phase

There are many different ways to develop software applications. We prefer to follow the design-first approach.
So, how does it work?

First of all, you need to develop a conceptual design and wireframes for future application. It shouldn’t be fully detailed. But it should provide a framework for future Requirement Definition activities.
They’ll be more engaged in the whole project when a difficult process of software development is simplified to images of the future product.
Another aspect of the Concept Development framework is technical.
Sometimes the required product is totally unique.
Or it has specific requirements that don’t have analogs. And no available solution will provide the desired outcome. So, you need to develop a brand new technological concept.

3. Planning phase

In large IT projects you’ll need to create a full Project Management Plan. However, in the beginning, you’ll work on smaller projects. Planning will be simple there.
Here’s the truth:
Many software development vendors develop a custom project management approach.
It’s naturally formed in the process of company growth.
So, you’ll need to follow either an utterly custom approach or a variation of Scrum or Kanban.
In this case, project planning brings into focus:

● Identifying project scope

● Estimates of time and costs

● Setting milestones

Sometimes you’ll need to identify required resources and expertise.
All other aspects of project management will be predefined by the customs of this organization.
Therefore, at the end of this phase, you’ll either have a Project Management Plan.
And, create a specific and clear timeline to deliver each item according to the deadline set out in the plan.

4. Requirements Definition phase

After you planned how to manage the project, you need to find out what you need to develop.
In this phase you can use all the available options to define requirements:
● Brainstorming
● Interviews
● Focus Groups
● Questionnaires and Surveys
● Document Analysis
● Mind Mapping
● Wireframes
● User Stories

There’s no specific approach to collecting requirements.
In the end, you need requirements that software engineers will understand.
Sometimes simple tweaks in requirements can cause a significant change in required efforts. For sure, you do want to keep an eye on such opportunities to simplify the future product.
After that, you may want to incorporate high-level feasibility analysis here.
That’s why you may often see the Requirements Traceability Matrix on software projects. Even in an agile environment.

5. Design phase

Again there are at least two aspects here:
1. Technical Architecture
2. UI/UX Design
During this framework, you need to analyze the collected requirements. After that, develop an architecture that’ll support them.

Also, you need a User Interface that’ll make the application or service usable.
The results of this phase are:
● Mockups
● Wireframes
● Workflow diagrams
● Architecture Description Documentation
● List of technologies, frameworks, and libraries
Once you have it all collected, you can start writing code to implement the requirements.

6. Development phase

At this stage, it’s time to all of your team dig into the real work . Software Developers will set up working environments and will start writing code. You’ll do the actual work here following one of the selected phases.
For the sake of better quality and engaged stakeholders, you can do it in an iterative and incremental manner.
What does that mean? You’ll develop a working piece of the application. You’ll show it to the stakeholders. After that, stakeholders will provide feedback. You’ll integrate changes to the project. So, your clients may still have hard deadlines and constraints.

7. Integration phase

Nowadays, you’ll rarely see an application that doesn’t integrate with other services or applications.
In enterprise environments, you’ll often see that employees’ data and credentials are stored in a separate service. You may need to integrate with it to get access to the database of the employees.
The storage space is often outsourced to one of the third-party providers like Amazon, Dropbox, etc. So, you need to integrate with it.
All-in-all, you need to integrate your piece of software with the business processes of the company or a market you sell the app.
This phase usually requires a lot of collaboration. It can be time-consuming.
So, you better plan this one ahead of time. Pay close attention to the possible risks and integration requirements of other services.
Quite often, integration’s a part of development.
However, if there are a lot of efforts involved, it’s better to get it done in a separate phase.

8. Testing phase

This framework is also referred to as Acceptance testing. Or final testing.
You need to understand that you should be testing your application continuously from the beginning. Moreover, you need to prevent defects in the process of development.
Ideally, your application should be stable and without serious defects all the time.
So, it’s a matter of Quality Assurance that you planned and executed in all previous frameworks.
Here you need to certify that the version of the application you’re testing is of the required quality.
It doesn’t mean that the application has no defects. They are present, but they don’t prevent people from using the application.
You do need to provide the list of all known defects in the application as part of the quality certificate.

9. Deployment phase

The software doesn’t work without hardware. Be that a server, your PC or Mac, or a mobile device you need to deliver your application or service there.
Moreover, the deployment of a big and complex application can be a project in itself.
You need to set up servers, upload your application, connect it with all the other services and servers.
In regards to mobile devices and desktops, you need to create an installer for the application. You may also need to submit this installer to the market (App Store, Google Play, etc.)
All in all, the result of this phase is your application or service available to the end users.

10. Maintenance phase

This is an important part of maintaining and developing a product that will be monitored, updated and maintained throughout its whole lifetime. It’s a part of a product life cycle that goes beyond the project life cycle.
However, quite often you may see a relatively short phase for maintenance.
During this period a part of the project team continues to work with the application after it gets to the users.
They are here to address any critical defects that were missed.
After a few months when the application’s used and “tested” by thousands of users the project team is released and the product is handed off to a separate support team.

11. Hand-off, Closure, Support phase

Hand-off can also require a lot of efforts.
You need to collect all the generated knowledge about the application and its specifics. After that, you need to transfer this knowledge to the support team.

Also, you may need to create documentation, specific capabilities to administrate the service and so on.
If that is the case, you do need to identify such requirements early on.
Also, think about the hand-off process at the beginning of the project.

The above discussed framework can help you ace your future projects. Can it be great If the discipline of the team goes hand in hand with enthusiasm and willingness to support each other, it is the key to creating a strong collective of technical and soft skills, don’t forget to keep that spirit.
We would love to know your thoughts on this blog. What other phases would you add to the list that works best for you? You can drop a comment below to share your tips, we’d love to hear your sharings!