|
|
|
|
Project Management |
That's how Capstone summarizes project management. It's about delivering software (or any other
valuable solution to a complex problem) on time, on budget, and on target.
On Time Software
The number one challenge many businesses face is delivering solutions to complex software projects on
time. Poorly understood requirements, changing scope, and competing priorities all contend for the
attention of limited IT resources and exert significant pressure on project schedules. Capstone's
iterative, incremental, phased approach (read more about these core concepts) creates an environment
which reacts well to change, allows for straight-forward and frequent course correction, and supports
effective scope management.
On Budget Software
Project schedule overrun almost always translates to cost overrun. Capstone's proven methodological
approach to software development creates repeatability not only in delivering on time, but delivering
vital and valuable scope within the budget constraints allotted.
Gantt Chart depicting an example of an Iterative Project Plan
On Target Software
The best software, even if delivered on time and on budget, won't deliver any value to the business if it doesn't
fulfill the vision, purpose and goals for which is was created. The end user is the customer, and
ultimately has the final say as to whether or not it was worth the time and cash to build ... whatever
it is the project team built. Capstone's program management processes are proven to
drive out the right requirements in the right timeframe and mitigate risk, enabling project teams to
deliver real value to the business, both early and often.
Capstone's approach to the Software Development Lifecycle (SDLC) is an iterative, incremental one. This
is evident in
our management of programs or projects,
our implementation of custom software for our customers,
and even our assessment services.
Capstone leverages important principles from key SDLC methodologies and schools of thought to provide our
customers with proven, repeatable processes for successfully taking critical projects to production.
Here are a few of the key contributors to Capstone's philosophy in managing projects...
The Rational Unified Process
The Rational Unified Process
(or "RUP") is an excellent framework for managing software development projects. But it is only a framework.
One common mistake made with RUP is that companies or teams "buy" it, and implement every aspect of it
they find on the CD when it arrives at their office. RUP, like many methodological approaches should be viewed as a template
to be customized to fit the unique needs of the business. Not all artifacts should be created for every
project. Not all tasks are always applicable. And certainly, it should be implemented iteratively.
Capstone's biggest takeaway from RUP is the phased lifecycle. The clear and insightful definitions of the
inception, elaboration, construction, and transition phases are very valuable in charting the course to
successful project delivery, provided that they are implemented iteratively and incrementally, as discussed
below.
Agile
Agile
is a set of common principles used to maximize the effectiveness and efficiency of a small set of software
development commandos. Principles such as "individuals and interactions over processes and tools" and
"customer collaboration over contract negotiations" elevate the skill and agility of the team over the
exhaustiveness or rigor of the methodology and associated artifacts.
Other Agile practices, such as test-driven and behavior-driven development, as well as "continuous
integration" are also driving forces in Capstone's project and program management methodologies.
Driving software development from pre-built test cases translates to establishing success criteria
for software development efforts. A behavior-driven approach adds necessary focus on user stories
and on continual interaction between technical development teams and business owners throughout the
lifecycle of each iteration, the project, and the entire initiative. Continual integration is a
similar concept, ensuring that changes to existing systems (whether software or people) are made
incrementally, grafting new features and functionality onto the existing core, rather than "bouncing
around" building silos of software functionality, corporate policy, business process, information
workflow, etc.
Capstone feels so strongly about these Agile principles that we have made it a core offering to provide
our customers Agile
training and strategic mentoring.
Scrum
Capstone has experienced a great deal of success delivering Agile principles in project management leveraging the
Scrum methodology.
Scrum focuses on short sprints to useable software, strongly relying
on dynamic interaction between the end users of a system and the technical resources developing it,
along with other Agile principles. Capstone's seasoned ScrumMasters are experienced purveyors of
effective software development.
There are a lot of buzzwords in the software development world, many promising an effective, repeatable
approach to delivering software solutions. But the processes actually in use at many companies, though
heavy on buzzwords, frequently lack the capacity to truly deliver the value the business needs when they
need it - early and often.
Capstone's proven software development methodology is not about buzzwords. We encourage customers to
question the buzz and deeply understand terms like "iterative" and "incremental" development, and to compare
Capstone's approach against industry best practices. Our extensive experience and long-term success
have made us confident in our methodologies, as well as their ability to repeatedly deliver significant value to our customers.
Let's go beyond the buzz on a few of these critical concepts in successfully developing complex software.
What is "iterative" software development?
The concept of building enterprise software (or anything complex) iteratively is about delivering usable solutions
early and often. Rather than locking a team, no matter how skilled, in a room for months or even
years until they have created a complete, "big bang" solution, delivery teams should be releasing new builds
of the software in days or weeks, not months or years. And these builds are not unstable hacked-together piles
of source code or prototypes that may (or may not) demonstrate value but be mostly thrown away later.
These are stable, usable, completed software products, which may be transitioned into production for use by
actual system users, if called for by the business. This is the value of a truly iterative process.
The other key best practice necessary to take full advantage of an iterative approach to software
development is acknowledging that an iteration means a full roundtrip through the software development
lifecycle. A common mistake with RUP, for example, is to claim that the process is iterative because
the project team went back to the end users several times in the elaboration phase to refine / clarify
requirements. A truly iterative RUP process will execute a small inception phase, a small elaboration
phase, then construction, then full transition to production ... ALL of which is a single iteration. The
second iteration returns to inception and begins the entire process again with slightly improved or
expanded functionality. Iterations are about incrementally expanding understanding and solution functionality
over time, not about cyclically digging deeper into the current phase of development.
When is software development "incremental"?
And that brings us to the definition of "incremental" software development. Once the SDLC process is truly
iterative, it's easy to make it incremental. Developing a solution incrementally means adding a little more
to the usable end-product during each iteration. It's about starting with a basic root of functionality,
and grafting on a little more each iteration until the product is as fully-featured and robust as is needed by
the business. Notice that this is exactly the opposite of the big bang approach, which envisions every
conceivable function or feature from which business users might benefit (in the eyes of the project planners,
business analysts, and technical team), and attempts to build it all in one shot.
When put that way, we believe it becomes clear why waterfall approaches (conceive it all, then document it
all, then build it all, then deploy it all, etc) to both software development and project management are failing,
and why an iterative, incremental approach is necessary to ensure success. And the more complicated the initiative,
the more true this principle is.
Capstone can help you deliver your critical projects, or even large-scale initiatives, according to these
principles. Let us show you how.
Contact Capstone Consulting
Visit Capstone's Resource Library
Subscribe to Capstone's Quarterly Newsletter
Learn more about events coming to your area
|