Help you reach your business goals
Deliver products that meet or exceed requirements
We achieve your objectives!
Vertical development provides business value early & often
Continuous feedback & improvement
Frequent risk assessment & mitigation
Use case driven methodology
Refinement from behavioral to logical to implementation models
Focus on modular architecture and design
Tracing of requirements through design & test
QA involvement in all lifecycle phases
Peer reviews of project deliverables
Client acceptance plan
Joint development of process model with client
“Follow the sun” development
Comprehensive communication plan
Mix of U.S. & China based skills & talents
Managing complex software development projects is about efficient utilization of resources, risk management, accurate estimation of budgets and timelines, experienced selection of appropriate technologies, and scheduling feature development to meet time-to-market requirements. Risk is a reality in every project; Objectiva’s iterative process for software development is designed specifically to mitigate risk. Let us explain how.The most important question to answer before starting product development is: Why is this product needed in the marketplace? The answer to this question constitute the business objectives of the product that should drive its entire lifecycle.A software product’s development lifecycle is comprised of four facets:
These four facets are managed by a project plan that determines when the software product will offer the required features.
In a traditional Waterfall lifecycle model, (shown to the right) the project plan organizes the four phases in a strict serial order. A lot of time is spent up front to define and analyze requirements and to complete the design of the target system before a line of code is written. This model does not handle changes in requirements or design well. In addition, it creates an artificial separation between business analysts, architects, designers, and programmers, leading to the risk of miscommunication and divergence between the business objectives and vision of a software product and its implementation.
Using an Iterative lifecycle model, the four facets of a software product are integrated so that business objectives drive the entire process, and the requirements and design are continuously refined while the code evolves. The project plan arranges the development into small releases, and mandates continuing integration of all coded components, incremental builds, and periodic validation of refined requirements and design. By doing so, it encourages a shared ownership of the product among business analysts, software architects, designer, programmers, and testers; this shared ownership reduces the risk of miscommunication and divergence. It also enables continuing refinement and integration to avoid any unpleasant surprises just before the delivery date.
Our name, Objectiva, is inspired by our focus on object modeling, object-oriented design, analysis and programming. We pursue a breadth-first approach that emphasizes developing a solid architecture and object-oriented design that allows implementing a working software system based on the design in the early stages of a project, and then refining the objects that make up the system gradually to obtain all required functionality. We consider the software architecture and design the core of a software product; the architecture can be viewed from four complementary models:
We use the Universal Modeling Language (UML) and UML modeling tools to model these four views of the architecture. The development of these models becomes the means through which we gather and analyze requirements, refine the design, and link the design pieces to the code. Having a UML model of the architecture also allows us to approve requirements and design pieces, and yet be able to refine and evolve them during coding without losing trace of how the refinement affects the code.
The UML models become a primary means of documenting the object-oriented design and communicating with developers, testers, technical writers, and business stakeholders about how the software product will deliver the needed functionality.
Within the UML models, our design methodology focuses on defining interfaces among objects and components first then designing the internals of each object. We also apply the 80/20 rule to get 80% of the functionality working in 20% of the time rather than obsessing about a single object and risk not delivering the software. We achieve this by making sure not to re-invent the wheel. For example, we use design patterns that fit the requirements of a project to establish a basis for the software design rather than developing every design from scratch.
For enterprise software systems, we use industry standards and platforms like J2EE, Microsoft .NET, and application servers as a basis for the enterprise software and then build custom objects on top of that.
We take every care to ensure that the software we build satisfies our client’s requirements. The only way to ensure that is to perform quality assurance throughout the software lifecycle. We typically involve a lead quality engineer in the early phases of a project to participate in requirements elicitation and analysis, to ensure that our quality assurance team understands the business objectives and the detailed requirements. This understanding enables the team to develop a comprehensive quality assurance plan for the project that includes the following elements:
The quality engineers staffed on a project are responsible for implementing, tracking and adjusting the quality assurance plan to make sure that it is completed successfully by the delivery date. They often use test automation tools to help them in conducting the required testing and establishing a complete regression test suite for the product that is as automated as possible.
We staff each project with an integrated, global team that includes the right mix of skills depending on the project needs. Typically, a global team will include project leadership (e.g., Project manager, Architect) both in the US and in China. Our iterative software lifecycle model is architecture-centric and requirements-driven. Therefore, we pay utmost attention to getting both the requirements and the architecture right. To ensure this, we bring the technical leadership of the team to the client location during requirements elicitation and architecture activities to ensure deep understanding of the requirements and the architecture. The technical leadership then transforms this knowledge to the rest of the team offshore. In addition, our US-based project managers travel to China to be with the team during critical junctions in the project. This ensures that the team behaves as a single unit.
Because of our global structure, we can form a team that works seamlessly on a 24-hour basis. The time difference between our locations in the US and China works to our advantage; the end of the working day in the US coincides with the beginning of the following working day in China. Any issues or problems left unsolved by the US-based team at the end of the working day are worked on by the China-based team and resolved before the following morning.
Our global delivery methodology ensures that team members in the US and in China form a cohesive team. We structure a communication plan to ensure open upward and downward communication lines between the client and us; between the design team and the development team; and between the business stakeholders and the development team. The communication plan is developed in the early phases of a project and is signed off by our clients.
Our method includes extensive on-boarding sessions to ensure that each team member understands the business objectives of the software product, the project plan, the requirements, their roles and responsibilities, and the communication plan. We follow that up with regular check-ins, email, instant messaging, conferencing and model-based communications (using a UML-based tool to communicate via models).
In any outsourced project, establishing the most effective project management is crucial. That is the reason why we take utmost care in assigning a project manager to a project. In most cases, the project manager is local to the client and works closely with the client liaison(s) throughout the project life-cycle.
The very first task of the project manager is to develop a comprehensive Project Management Plan (PMP) that establishes the following:
A world-class software organization must use tools that enable it to go through a project lifecycle in the most efficient manner possible.
At Objectiva, we have built an infrastructure of tools in the following areas: