Describing Solution Architectures

Pragmatic Approach to Describing Solution Architectures

by Mike Walker

Summary: The return on investment of technical documentation is often not realized and documentation is frequently looked upon as a necessary evil. Creating the right architecture descriptions can help guide decision making at the various stages of the IT life cycle, however, there are limitations on formalized structures, information models, and intelligent tooling that takes the current architecture documentation to the next level of usefulness. In this article, we look at how we view, approach, and maintain architecture descriptions, and consider how this process can be improved.

 

 

Since the dawn of information technology (IT), engineers and architects have created reams of documents to describe their solutions. These have been published in three-ring binders and placed in obscure places on bookshelves, eventually to collect dust and be forgotten — something with which engineers and architects have had to deal as a fact of life.

As time has passed, documentation has evolved from a listing of detailed methods and procedures to the separation of multiple aspects of the solution from the detailed APIs and user-interface (UI) design to the architectural aspects. Integration with developmental and architectural processes furthered this activity and, eventually, became a required and common practice. By doing so, governance processes in many ways restricted forward progress. In many ways, governance has created both justified and unjustified restrictions to forward-moving progress on designs and coding, if a set of documentation had not been completed. This has led to frustration and productivity blockers. Current architecture documentation does not live up to the promise of providing return on investment in the design process. Often, the design that is articulated in architecture documentation is not realized in the final implemented design that is hosted in a production environment.

This pervasive growth of documents shows how critical the information is to the support of the software-development life cycle (SDLC). We now see the same with the support of architecture efforts, too. There are a number of challenges that occur with this paradigm.

 

Figure 1: Documentation, increasing at an accelerated rate

 

As Figure 1 shows, we are adding more and more documents to an already large portfolio of documents that must be completed. In the past, this was manageable; now, however, documents can be bloated, and there is a higher probability of information being duplicated. Often, this is a result of tightly coupling a document with a process step.

The goal is to solve the deficiencies and challenges with current architecture documentation while preserving the aspects that do work and have been assimilated into the daily lives of architects.

To do this, we will explore the following concepts:

• Alleviating challenges with current documents — Templates and new thought-provoking ideas will be introduced that challenge the existing ways of documenting architectures.
• Living architecture designs — Designs often are static and do not have a life outside of the development life cycle. We will introduce ways to change that.
• Enhancing decision support — Often, there are templates and checklists that give an architect a common way to think about problems. This is an accelerator to solving problems that have yet to be solved or identified.
• Deriving to solutions — Given how the human mind works, writing down a design to a specific problem in “black and white” often shows gaps in current thinking.
• Common means of collaboration — These provide a working information store to share and collaborate on architectures with team members.
• Supportability and maintainability — Documents provide important information on how a system was built. This provides support personnel with vital information for solving postproduction issues. For architects, the understanding of current system architecture will allow them to build out a set of strategies for the enterprise.

 

 

Rethinking the Traditional Architecture Document

The most common and pervasive interface for creating architecture descriptions is Microsoft Office Word. Office Word is part of the Microsoft Office suite of productivity tools. With documentation, there are many other tools that play a role in the documentation processes.

 

Figure 2: Microsoft Office Word reduces complexity and cost

 

As Figure 2 shows, Office provides a way to reduce complexity and costs significantly. The Office suite is easy to understand and most users already have them on their desktops. Augmenting the existing Office tools to make them fit the usage of architects is particularly ideal. It maintains a consumable amount of complexity while limiting the overall costs. However, Office Word is not the only tool that is used in the architectural processes. There are many other tools that have roles to play in how we document our architectures. These tools include the following:

• Office Visio

• Office PowerPoint

• Office Excel

• Office SharePoint

It is important to understand the context in which these tools interact.

 

Figure 3: Other productivity tools playing a role in the documentation process

 

Figure 3 shows an illustration of how other productivity tools play a part in architectural processes.

We can assert quickly that there is not just one tool that used in the documentation of architecture; myriad tools are used for collecting information from or publishing to. If we want to solve the challenges with the process, we should keep this in mind.

 

 

Optimizing Office Word to Describe Architectures

The underlying goal is to change the role of Office Word from simply a word processor to more of a UI for designing architectures. Applying structured UI concepts to Office Word provides many benefits to the architecture document, including the following:

• Structured content — Information can be better described in the document. We want to do this because of the challenges mentioned regarding how information does not integrate well with process or future design activities. One example is the process of importing a model into an architecture document. Often, we import a picture that represents a model of the specific viewpoint of an architecture. If we had an information model, we could specify that the model imported is indeed the logical model, instead of a generic image file.
• Extensible — With a little more structure, information has meaning and definition. This makes the information extensible to other processes downstream.
• Consumable — Ability to consume external content is also possible with a more structured interface. As an example, if you so choose, you could import external architecture information from other systems to automate your design efforts.

Through the use of the Office Word 2007 features that center on XML, we can truly start to extend this interface. Word does so by providing:

• Embedding XML documents — embed XML file into document for full data qualification.
• Office Word XML format — fully describes the formatting from the data through XML to have true separation of the formatting versus the information.
• Content controls — map most content controls to elements in XML data attached to a document.

Building the new UI for the architecture documents is easier in Office Word. A series of out-of-the-box functions are provided in the Office Word interface. For the architecture document, we will use the built-in tools that Office Word provides to create this new UI, which will enable us to describe our information in a meaningful way.

 

 

The Architecture of the System-Architecture Document

To change fundamentally how architects use a system-architecture document, we must look at what services Office Word provides to add additional capabilities that will automate and create rich metadata integration services.

For this solution, we will use a real world reference architecture called the Enterprise Architecture Toolkit (EATK). This toolkit will show how to alter Office Word from a word processor to a UI for describing architectures in a new way. The Microsoft Office environment provides rich extensibility that will allow developers to extend in a meaningful way. To do so, an architectural approach will have to be taken. By separating out layers and capabilities, approaches and technologies can be identified to derive to the right solution.

 

Figure 4: Architectural layers

 

As Figure 4 shows, there are four architectural layers that expose discrete services for this solution. These include the following:

• Platform — This is what the solution-architecture document and the integration services connect to. The platform components integrate with Office SharePoint Application Server environment for rich line-ofbusiness (LOB) integration.
• Tool — The mechanism of Office Word is referred to here. The tool provides extensibility into the UI that provides Microsoft Office ribbons to execute tasks easily with a level of context and Microsoft Office task panes that extend the UI with additional entry or listings of information.
• Document — The document provides the way in which a user can enter architecture descriptions. This is different in the EATK, as the document acts as the glue between the tool and the information itself. This is accomplished through an architecture-document template and the use of Office Word custom controls.
• Information — The information in the document is managed completely different from a traditional document. All of the information that is typed into the document is linked back to an XML node behind the scenes. This fully qualifies what is typed. Not only is the information rich, but it is extensible.

 

 

Platform Architecture

A great deal of work has been done in building componentized add-ins at the tooling level in Office Word, but this is not enough to change fundamentally the architecture document into a tool for designing architectures. The components that are applied to Office Word build upon a larger architecture canvas. The EATK provides a server-side Architecture Portal and Architecture Meta-Data Repository (AMR). This architecture interacts with the document-level activities when we create an architecture design.

 

Figure 5: Architecture behind EATK system-architecture document

 

Figure 5 shows a logical representation of the architecture that the EATK provides. It leverages a series of Microsoft-platform technologies, which include the following:

• Microsoft Office SharePoint (MOSS) 2007 — Used as an Architecture Portal, Document Management Services, and Workflow
• Windows Workflow Foundation (WF) — The hosted workflow on the portal that interacts with the desktop application and add-ins
• Microsoft Project Server — Can be used as the platform for interacting with project and portfolio data
• Microsoft SQL Server — Used as the database platform for the AMR that the Office Word add-ins Patterns Browser and Architect Lookup will use to get their information
• Microsoft IIS 7.0 — Used as the hosting platform for the AMR Services layer

The server components in the EATK play a part in how we change the role of an architecture document. All of the components on the server leverage platform capabilities of Office SharePoint, but change the context in which they can be used. The context is the architecture-development process. In doing so, we can take generic capabilities such as Enterprise Content Management (ECM) to automate how information is audited and versioned. The following are new interfaces and EATK components that were developed specifically for the architectural process and to interact directly with the system-architecture document:

• AMR Web Services — Services layer that allows for programmatic interaction with the AMR. It provides extensibility into not only the AMR, but also other related services such as PPM or Application Portfolio Management (APM).
• AMR Data Services — The base information services that delivers information such as patterns and existing IT assets to the Office Word task panes.
• Document-Management Services — An Office SharePoint–based set of services that are used to manage documents. It comprises functionality such as check-in, auditing, versioning, integrating with workflow, security, and archiving.
• Workflow Services — WF is used as the base of the workflow capabilities. Also, it is hosted on the server, which allows the architecting workflows that are applicable to the entire enterprise, instead of to just one architect.

 

 

Tool Architecture

This aspect of the solution is key to bridging the system-architecture document to both the platform for LOB integration and the document itself, which will be the interface in which architects will describe their solutions. All of the application logic is encapsulated in this layer.

Because this is the layer in which code is developed, this solution is dependent on Office Word API and other standard integration technologies.

 

Figure 6: Components of Office Word interface

 

Figure 6 shows the extended capabilities of Office Word. We have extended the following aspects of Office Word:

• Ribbons — We use this functionality as a launch pad for downstream activities, workflow triggering, collaboration, and information retrieval.
• Task panes — We can use this functionality for various aspects in which we want to create other interfaces from within Office Word.
• Properties — Assigning metadata to a document

 

 

System-Architecture Document Ribbons

Using the ribbon for the system-architecture document, we will have a series of functions that relate directly to architectural processes and information. As Figure 7 shows, there are four ribbon components in the EATK:

 

Figure 7: Ribbon components of system-architecture document

 

• Patterns Search — It displays patterns and existing IT assets that will help solve specific architecture-design questions and challenges.
• Patterns Browser — It allows for surfacing the right patterns in a more intuitive way for solving a business problem.
• Architect Lookup — Looking up an architect who is assigned to a project is streamlined with Architect Lookup by integrating collaboration via office communication server (ocs)
• Upload Doc — Automatically have a way to integrate architecture information into hosted workflow and consumed into a metadata repository.

 

 

System-Architecture Document Task Panes

Task panes can be very useful to architects, as they can surface meaningful information at a moment’s notice with a click of a ribbon component. This information is not only visible, but also interactive.

Tangible ways in which these task panes empower IT architects are the following:

• Systematic reuse — Many of the architectures that we build have repeatable patterns built within. By surfacing patterns in a composite manner, we can reuse the aspects and views of architectures in a systematic way.
• Decision support — By reviewing existing architectures, we can review how solutions were developed based on a set of drivers. Not only can you review, but also you can contrast decisions on these architectures with the challenges of the current architecture efforts.
• Automation — Not only can you view the patterns and assets in the task pane, but also you can apply them to your architecture design. By reusing models and architectural descriptions, you can automate the architectural process by eliminating unnecessary work.
• Traceability of technology choices — Not only can you surface this information and apply it to your architecture designs, but now you can create relationships between what was imported and the architecture that you are designing.

As one example of this is the Patterns Browser. The intent of the Patterns Browser is to surface pattern information into the design environment. Two types of information are displayed:

• Assets — Shows what has been built.
• Patterns — Shows what should be built.

As Figure 8 shows, patterns can be applied to the elements of an existing architecture. In the preceding case, it is the reuse of a logical architecture model. Appling the selected model is as easy as double-clicking the pattern in the Patterns Browser. The pattern then is applied to the element that is selected in the document.

 

Figure 8: Interacting with elements in document

 

Another innovative way the Task Pane is utilized is by introducing collaboration. The architectural process is no longer a onearchitect job. Typically multiple architects with specific roles design systems architecture. Examples of these roles include; Application, Information, Hardware, Security, or Infrastructure architect.

Other roles in review processes will have an impact on the validity, quality, and level of completeness of the designs. This affects the architecture in a significant way, too. These roles usually are part of an Architectural Review Board of sorts. In this function, it is critical that the architecture document give this group of individuals the information that it needs to make decisions on the architecture. By introducing the collaborative aspects to the architectural process, we can reduce the number of issues ahead of time, instead of at the end of the process — thus, changing the architecture-design process from its current form of a reactive process to a proactive process.

 

Figure 9: Architect Lookup task pane

 

Architect Lookup would return the names and photos of the Hardware, Security, and Information architects. As Figure 9 shows, the Architect Lookup task pane reveals the architect resources, based on the project that is assigned to the architecture work. The way in which Architect Lookup determines this is by using the assigned project ID. The project ID is found in the meta-data of the document. This metadata can be entered either manually or through automated means when the architecture-design request is sent.

Architect Lookup will take the project ID and perform a query against multiple systems to return a set of results. Project Server (or a custom information store) can be used to retrieve the list of architect resources, while Office SharePoint and Active Directory are used to take the resources in the PPM repository and correlate them with the images of the person, along with links to IM and personal portal sites.

Use of Architect Lookup eliminates the need to go to project plans, portals, or file shares to find this information manually. It is a simple click away to get instant access to other resources on the project, to get answers to questions.

 

Figure 10: Collaborative architectures

 

Each role has a part to play in the architectural process. Given the illustration in Figure 10, we see that an Application architect might start the process, but then might need the aid of other architects. In this case, the Application architect might be the owner of the document and be the primary contributor. The other roles that are shown — such as Hardware architect, Security architect, and Information architect — are some that would interact. These roles will validate, add, and modify architecture-design descriptions.

In this context, a sample of common questions to these roles would look like the following:

• How will the security model affect how I design my application?
• I know that I must design an external portal, but what does the servertier model look like for the DMZ?
• What will the network stack look like, and how will that affect performance or scalability?
• What is the right hardware?

 

 

Document-Template Architecture

Along with enhancements to the tool, the next layer of concern is the document template.

The document-template layer does not have a great deal of intelligence to it; however, it does allow interaction from Office Word to the document. One example is that the EATK allows information from an external source to be “clicked and dragged” into the document. This pulls data from a database and populates the document with architecture models.

The EATK provides not only the Office Word add-ins that are described in the previous sections of this article, but also a system-architecture document template, as Figure 11 shows:

 

Figure 11: System-architecture document template

 

The views that are listed in the table of contents are a set of common views. These views can be renamed or removed, and additional views can be added. These views provide a starting point for architects. Whereas you can use the system-architecture document template as your corporate standard in your company, it will be common practice to modify it.

With many documents that are surrounded by process, we want to create templates to ensure that they are used in a consistent way. This is the same case with the system-architecture document template. A template for the architecture document will allow for:

Everyone using the right version of the architecture document.

• Ensuring that the information models stay intact.
• Allowing for information to be generated by the system.
• Enabling information to be consumed by downstream processes.

 

 

Information Architecture

The last piece of the puzzle is the information itself. Having great add-ins and template is great; however, without a meaningful way to express and ensure that the information is long living in a connected process, it is not as useful as it could be. Without information architecture, it would be difficult to qualify architectures.

The information layer is the base of the solution; it is where the majority of the consideration is made. All layers interact with each other in some way, but the information layer is connected directly to all. It is consumed in workflows, information-entry processes, and automation through Microsoft Office ribbons and task panes.

By using industry-standard techniques to derive to the target information architecture. Two fundamental aspects of the EATK that we must explore are the following:

• Ontology — We want to define a set of terms that are understood commonly within the enterprise. By doing so, we can relate information properly and consistently.
• Taxonomy — This will allow you to correlate architecture information with other aspects of architecture.

The architecture document should use the terms in the proper usage to qualify what the information is. Publishing an online ontology mapping will be useful toward understanding the information within the document.

In the context of the system-architecture document, ontology provides agreed-upon terminology for architecture. As an example, it would define the meanings of a platform, system, subsystem, application, and components.

Defining what these architecture elements are, however, is one piece of the puzzle. How these elements relate to each other is the next logical step. We will use taxonomy for this. The EATK uses an industry standard from IEEE to solve this challenge. IEEE 1471 is used as the basis for the taxonomy and ontology of the system-architecture document.

IEEE 1471 is the first formalized standard for describing architectures and how they relate to other aspects of the software-development process. It leverages a scalable meta-model that shows the relationships between common elements in the architecture-development process.

 

Figure 12: IEEE framework for architectural description

 

In Figure 12, IEEE 1471 provides a meta-model that allows us to relate architectures with other aspects of the software-development process. The system-architecture document focuses on specific areas of the taxonomy, while other EATK components focus on other aspects of the standard.

The aspects that are implemented to support IEEE 1471 in the systemarchitecture document are the following:

• Structured content — An architecture schema that represents the information that we want to gather in our architecture document was created that has a viewpoint-based model applied to it.
• Qualifying information — Links between decisions that have been made and other systems or architecture descriptions are built into the schema. As a user enters information or applies patterns to the architecture document, it will correlate that information by unique ID.
• Publishing mechanisms — Provides facilities to store information from the schema, so that it can be related to other non-document–related information.
• Generating information — Provides a mechanism to rebuild or generate sections of an architecture document.

 

 

System-Architecture Markup XML

With an ontology and taxonomy for architecture, we now can look at what this means from an implementation perspective. The system-architecture document has an underlying XML structure that is used to describe the information in the form of XML.

The System Architecture Markup XML is a way to provide clear separation between the presentation markup and the information markup.

This greatly simplifies integration to hosted workflow, repositories, and third party tooling.

Conclusion

In this article, we reviewed how to change fundamentally the way in which we view, approach, and maintain architecture descriptions. There is no doubt that there could be significant value in capturing information about the designs of our architectures that will help guide decision makers through the processes of making the right architecture decisions. However, this is not always the outcome, as often no formalized structure, process, information model, or intelligent tooling is bundled with this process.

Key takeaways include the following:

• Architects who want to implement these concepts can use the EATK, which provides a set of templates, processes, and a solution accelerator that can be used to accelerate this implementation for architects.

• Architects can achieve significant productivity gains through reduction of manual activities and process automation.

• Architecture information can be used in a much more meaningful way by eliminating the document graveyard effect, by integrating architecture descriptions with an AMR.

• The quality of decision making can be improved by eliminating points of duplication; thus, information quality can be increased significantly.

• Wikis and modeling tools complement this implementation—or, in some cases, replace it.

• Solutions such as COTS and custom-developed applications can be integrated with this solution through standard integration technologies.

About the Author

Mike Walker is a principle architect who delivers strategy for the enterprise architecture space at Microsoft. He is responsible for creating, driving, and evangelizing Microsoft’s worldwide Enterprise 2.0 and Enterprise Architecture strategies. Specifically, Mike ensures that institutions around the world realize the full extent of Microsoft’s vision and value proposition. He has also evolved many of the concepts behind mainstream architectural approaches and styles. His works are realized through publication in books, trade publications, authoritative architecture guidance, articles, code delivery and standardized frameworks. Those frameworks include: the Enterprise Architecture Toolkit (EATK), Loan Origination Reference Architecture, and Financial Services Component Library. You can visit his blog a thttp://www.MikeTheArchitect.com

Software Architecture

A Language for Software Architecture

by J.D. Meier

Summary: One of the most important outcomes of the patterns & practices Application Architecture Guide 2.0 project is a language for the space: a language for application architecture. Building software applications involves a lot of important decisions. By organizing these decisions as a language and a set of mental models, we can simplify organizing and sharing information. By mapping out the architecture space, we can organize and share knowledge more effectively. By using this map as a backdrop, we can also overlay principles, patterns, technologies, and key solutions assets in meaningful and relevant ways. Rather than a sea of information, we can quickly browse hot spots for relevant solutions.

 

 

A Map of the Terrain

One of the most effective ways to deal with information overload is to frame a space. Just like you frame a picture, you can frame a problem to show it a certain way. When I started the patterns & practices Application Architecture Guide 2.0 project, the first thing I wanted to do was to frame out the space. Rather than provide step-by-step architectural guidance, I thought it would be far more valuable to first create a map of what’s important. We could then use this map to prioritize and focus our efforts. We could also use this map as a durable, evolvable backdrop for creating, organizing and sharing our patterns & practices work. Figure 1 shows the main map, the Architecture Frame, we created to help us organize and share principles, patterns, and practices in the application architecture space.

 

Figure 1: Architecture Frame

 

 

Mapping Out the Architecture Space

Creating the map was an iterative and incremental process. The first step was to break up application architecture into meaningful buckets. It first started when I created a project proposal for our management team. As part of the proposal, I created a demo to show how we might chunk up the architecture space in a meaningful way. In the demo, I included a list of key trends, a set of application types, a set of architectural styles, a frame for quality attributes, an application feature frame, a set of example deployment patterns, and a map of patterns & practices solution assets. I used examples where possible simply to illustrate the idea. It was well received, and it served as a strawman for the team.

Each week, our core Application Architecture Guide 2.0 project team met with our extended development team, which primarily included patterns & practices development team members. During this time, we worked through a set of application types, created a canonical application, analyzed layers and tiers, evaluated key trends, and created technology matrix trade-off charts. To create and share information rapidly, we created many mind maps and slides. The mind maps worked well. Rather than get lost in documents, we used the mind maps as backdrops for conversation and elaboration.

Key Mapping Exercises

We mapped out several things in parallel:

• Key trends. Although we didn’t focus on trends in the guide, we first mapped out key trends to help figure out what to pay attention to. We used a mind map and we organized key trends by application, infrastructure, and process. While there weren’t any major surprises, it was a healthy exercise getting everybody on the same page in terms of which trends mattered.

• Canonical application. The first thing we did was figure out the delta from the original architecture guide. There were a few key changes. For example, we found that today’s applications have a lot more clients and scenarios they serve. They’ve matured and they’ve been extended. We also found today’s applications have a lot more services, both in terms of exposing and in terms of consuming. We also noticed that some of today’s applications are flatter and have fewer layers. Beyond that, many things such as the types of components and the types of layers were fairly consistent with the original model.

• Layers and tiers. This was one of the more painful exercises. Early in the project, we met each week with our development team, along with other reviewers. The goal was to map out the common layers, tiers, and components. While there was a lot of consistency with the original application architecture guide, we wanted to reflect any learnings and changes since the original model. Once we had a working map of the layers, tiers, and components, we vetted the map with multiple customers.

• Application types. We originally explored organizing applications around business purposes or dominant functionality, customer feedback told us we were better off optimizing around technical types, such as Web application or mobile client. They were easy for customers to identify with. They also made it easy to overlay patterns, technologies, and key patterns & practices solution assets. The technical application types also made it easy to map out relevant technologies.

• Architectural styles. This is where we had a lot of debate. While we ultimately agreed that it was helpful to have a simple language for abstracting the shapes of applications and the underlying principles from the technology, it was difficult to create a map that everybody was happy with. Things got easier once we changed some of the terminology and we organized the architectural styles by common hot spots. It then became obvious that the architectural styles are simply named sets of principles. We could then have a higher level conversation around whether to go with object-based community or message-based and SOA, for example. It was also easy to describe deployments in terms of 2-tier, 3-tier, and N-tier.

• Hot spots for architecture. When you build applications, there’s a common set of challenges that show up again, such as caching, data access, exception management, logging, and so on. These are application infrastructure problems or cross-cutting concerns. You usually don’t want to make these decisions ad hoc on any significant application. Instead, you want to have a set of patterns and guidelines or ideally reusable code that the team can leverage throughout the application. What makes these hot spots is that they are actionable, key engineering decisions. You want to avoid do-overs where you can. Some do-overs are more expensive than others. One of the beauties of the architecture hot spots is that they helped show the backdrop behind Enterprise Library. For example, there’s a data access block, a caching block, a validation block, and so forth.

• Hot spots for application types. When you build certain classes of application, there’s recurring hot spots. For example, when you build a rich client, one of the common hot spots to figure out is how to handle occasionally disconnected scenarios. The collection of hot spots for architecture served as a baseline for finding hot spots in the other application types. For example, from the common set of hot spots, we could then figure out which ones are relevant for Web applications, or which additional hot spots would we need to include.

• Patterns. Mapping out patterns was a lengthy process. Ultimately, we probably ended up with more information in our workspace than made it into the guide. To map out the patterns, we created multiple mind maps of various pattern depots. We summarized patterns so that we could quickly map them from problems to solutions. We then used our architecture hot spots and our hot spots for application types as a filter to find the relevant patterns. We then vetted the patterns with customers to see if the mapping was useful. We cut any patterns that didn’t seem high enough priority. We also cut many of our pattern descriptions when they started to weight the guide down.

We figured we had plenty of material and insight to carve out future pattern guides and we didn’t want to overshadow the value of the main chapters in the guide. We decided the best move for now was to provide a Pattern Map at the end of each application chapter to show which patterns are relevant for key hot spots. Customers seemed to like this approach, and it kept things lightweight.

• Patterns & practices solution assets. This was the ultimate exercise in organizing our catalog. We actually have a large body of documented patterns. We also have several application blocks and factories, as well as guides. By using our architecture frame, it was easier to organize the catalog. For example, the factories and reference implementations mapped to the application types. The Enterprise Library blocks mapped to the architecture hot spots. Several of the guides mapped to the quality attributes frame. For more information, see Cheat Sheet – patterns & practices Catalog at a Glance posted to CodePlex athttp://blogs.msdn.com/jmeier/archive/2008/10/09/cheat-sheet-patterns-practices-catalog-at-a-glance-posted-to-codeplex.aspx.

• Microsoft platform. This was a challenge. It meant slicing and dicing the platform stack in a meaningful way as well as finding the right product team contacts. Once we had our application types in place, it got a lot easier. Depending on which type of application you were building — rich internet application (RIA), Web, mobile, for example — this quickly narrowed down relevant technology options. We created technology matrices for presentation technologies, integration technologies, workflow technologies, and data access technologies. Since the bulk of the guide is principle and pattern based, we kept these matrices in the appendix for fast lookups.

 

 

Key Components of the Application Architecture Map

Over the weeks and months of the project, a very definite map of the landscape emerged. We found ourselves consistently looking for the same frames to organize information. While we tuned and pruned specific hot spots in areas, the overall model of common frames was helping us move through the space quickly.

• Architecture frame. The architecture frame was the main organizing map. It brought together the context (scenarios, quality attributes, requirements/constraints), application types, architectural styles, and the application hot spots.

• Application types. For application types, we optimized around a simple, technical set that resonated with customers, such as Web application, RIA, and mobile.

• Quality attributes. We organized quality attributes by key hot spots: system, runtime, design-time, and user qualities.

• Architectural styles. We organized architectural styles by key hot spots: communication, deployment, domain, interaction, and structure.

• Requirements and constraints. We organized requirements by key types: functional, non-functional, technological. We thought of constraints in terms of industry and organizational constraints, as well as by which concern (for example, constraints for security or privacy).

• Application feature frame. The application feature frame became a solid backdrop for organizing many guidelines through the guide.

The hot spots resonated: caching, communication, concurrency and transactions, configuration management, coupling and cohesion, data access, exception management, layering, logging and instrumentation, state management, structure, validation and workflow.

• Application type frames. The application type frames are simply hot spots for key application types. We created frames for: Web applications, RIA, mobile applications, rich client applications and services.

Layered architecture reference model. The canonical application is actually a layered architecture reference model. It helps show the layers and components in context.

• Layers and tiers. We used layers to represent logical partitions and tiers for physical partitions (this precedent was set in the original guide.) We identified key components within the key layers: presentation layer, business layer, data layer, and service layer.

• Pattern maps. Pattern maps are simply overlays of key patterns on top of relevant hot spots. We created pattern maps for the application types.

• Product and technology maps. We created technology matrices for relevant products and technologies. To put the technologies in context, we used application types where relevant. We also used scenarios. To help make trade-off decisions, we included benefits and considerations for each technology.

 

 

User, Business, and System Perspective

One thing that helped early on was creating a Venn diagram of the three perspectives, user, business, and system, as shown in Figure 2.

 

Figure 2: User, Business, and System Perspectives

 

In application architecture, it’s easy to lose perspective. It helps to keep three perspectives in mind. By having a quick visual of the three perspectives, it was easy to remind ourselves that architecture is always a trade-off among these perspectives. It also helped remind us to be clear which perspective we’re talking about at any point in time. This also helped resolve many debates. The problem in architecture debates is that everybody is usually right, but only from their perspective. Once we showed people where their perspective fit in the bigger picture, debates quickly turned from conflict to collaboration. It was easy to move through user goals, business goals, and system goals once people knew the map.

 

 

Architecture Frame

The Architecture Frame is a simple way to organize the space (Figure 1). It’s a durable, evolvable backdrop. You can extend it to suit your needs. The strength of the frame is that it combines multiple lenses.

Here are the key lenses:

• Scenarios. This sets the context. You can’t evaluate architecture in a vacuum. You need a backdrop. Scenarios provide the backdrop for evaluation and relevancy.

• Quality attributes. This includes your system qualities, your runtime qualities, your design-time qualities and user qualities.

• Requirements / constraints. Requirements and constraints includes functional requirements, non-functional requirements, technological requirements, industry constraints and organizational constraints.

• Application types. This is an extensible set of common types of applications or clients. You can imagine extending for business types. You can imagine including just the types of applications your organization builds. Think of it as product-line engineering. When you know the types of applications you build, you can optimize it.

• Architectural styles. This is a flat list of common architectural styles. The list of architectural styles is flexible and most applications are a mash up of various styles. Architectural styles become more useful when they are organized by key decisions or concerns.

• Application feature frame. The application feature frame is a concise set of hot spots that show up time and again across applications. They reflect cross-cutting concerns and common application infrastructure challenges.

 

 

Application Types

We defined a simple set of technical application types:

• Web applications. Applications of this type typically support connected scenarios and can support different browsers running on a range of operating systems and platforms.

• RIA. applications of this type can be developed to support multiple platforms and multiple browsers, displaying rich media or graphical content. Rich Internet applications run in a browser sandbox that restricts access to some devices on the client.

• Mobile applications. Applications of this type can be developed as thin client or rich client applications. Rich client mobile applications can support disconnected or occasionally connected scenarios. Web or thin client applications support connected scenarios only. The device resources may prove to be a constraint when designing mobile applications.

• Rich client applications. Applications of this type are usually developed as stand-alone applications with a graphical user interface that displays data using a range of controls. Rich client applications can be designed for disconnected and occasionally connected scenarios because the applications run on the client machine.

• Services. Services expose complex functionality and allow clients to access them from local or remote machine. Service operations are called using messages, based on XML schemas, passed over a transport channel. The goal in this type of application is to achieve loose coupling between the client and the server.

 

 

Application Feature Frame

This is the set of hot spots for applications we defined:

• Authentication and authorization. Authentication and authorization allow you to identify the users of your application with confidence, and to determine the resources and operations to which they should have access.

• Caching and state. Caching improves performance, reduces server round trips, and can be used to maintain the state of your application.

• Communication. Communication strategies determine how you will communicate between layers and tiers, including protocol, security, and communication-style decisions.

• Composition. Composition strategies determine how you manage component dependencies and the interactions between components.

• Concurrency and transactions. Concurrency is concerned with the way that your application handles conflicts caused by multiple users creating, reading, updating, and deleting data at the same time. Transactions are used for important multi-step operations in order to treat them as though they were atomic, and to recover in the case of a failure or error.

• Configuration management. Configuration management defines how you configure your application after deployment, where you store configuration data, and how you protect the configuration data.

• Coupling and cohesion. Coupling and cohesion are strategies concerned with layering, separating application components and layers, and organizing your application trust and functionality boundaries.

• Data access. Data access strategies describe techniques for abstracting and accessing data in your data store. This includes data entity design, error management, and managing database connections.

• Exception management. Exception-management strategies describe techniques for handling errors, logging errors for auditing purposes, and notifying users of error conditions.

• Logging and instrumentation. Logging and instrumentation represents the strategies for logging key business events, security actions, and provision of an audit trail in the case of an attack or failure.

• User experience. User experience is the interaction between your users and your application. A good user experience can improve the efficiency and effectiveness of the application, while a poor user experience may deter users from using an otherwise well-designed application.

• Validation. Validation is the means by which your application checks and verifies input from all sources before trusting and processing it. A good input and data-validation strategy takes into account not only the source of the data, but also how the data will be used, when determining how to validate it.

• Workflow. Workflow is a system-assisted process that is divided into a series of execution steps, events, and conditions. The workflow may be an orchestration between a set of components and systems, or it may include human collaboration.

 

 

Architectural Styles

For architectural styles, we first framed the key concerns to organize the architectural styles, and then we defined some common architectural styles.

Organizing Architectural Styles

These are the hot spots we used to organize architectural styles:

• Communication. Service-Oriented Architecture(SOA) and/or Message Bus and/or Pipes and Filters.

• Deployment. Client/server or 3-Tier or N-Tier.

• Domain. Domain Model or Gateway.

• Interaction. Separated Presentation.

• Structure. Component-Based and/or Object-Oriented and/or Layered Architecture.

Architectural Style Frame

These are some commonly recognized architectural styles:

• Client-server. Segregates the system into two applications, where the client makes a service request to the server.

• Component-based architecture. Decomposes application design into reusable functional or logical components that are location-transparent and expose well-defined communication interfaces.

• Layered architecture. Partitions the concerns of the application into stacked groups (layers) such as presentation layer, business layer, data layer, and services layer.

• Message-bus. A software system that can receive and send messages that are based on a set of known formats, so that systems can communicate with each other without needing to know the actual recipient.

• N-tier/3-tier. Segregates functionality into separate segments in much the same way as the layered style, but with each segment being a tier located on a physically separate computer.

• Object-oriented. An architectural style based on division of tasks for an application or system into individual reusable and self-sufficient objects, each containing the data and the behavior relevant to the object.

• Separated presentation. Separates the logic for managing user interaction from the user interface (UI) view and from the data with which the user works.

• Service-oriented architecture. Refers to Applications that expose and consume functionality as a service using contracts and messages.

 

 

Quality Attributes

For quality attributes, we first framed the key categories to organize the quality attributes, and then we defined some common quality attributes.

Organizing Quality Attributes

Table 1 shows a simple way to organize and group quality attributes:

 

Table 1: Quality Attributes

 

Quality Attribute Frame

Some common quality attributes include:

• Availability. Availability is the proportion of time that the system is functional and working. It can be measured as a percentage of the total system downtime over a predefined period. Availability will be affected by system errors, infrastructure problems, malicious attacks, and system load.

• Conceptual integrity. Conceptual integrity is the consistency and coherence of the overall design. This includes the way that components or modules are designed, as well as factors such as coding style and variable naming.

• Flexibility. The ability of a system to adapt to varying environments and situations, and to cope with changes in business policies and rules. A flexible system is one that is easy to reconfigure or adapt in response to different user and system requirements.

• Interoperability. Interoperability is the ability of diverse components of a system or different systems to operate successfully by exchanging information, often by using services. An interoperable system makes it easier to exchange and reuse information internally as well as externally.

• Maintainability. Maintainability is the ability of a system to undergo changes to its components, services, features, and interfaces as may be required when adding or changing the functionality, fixing errors, and meeting new business requirements.

Manageability. Manageability is how easy it is to manage the application, usually through sufficient and useful instrumentation exposed for use in monitoring systems and for debugging and performance tuning.

• Performance. Performance is an indication of the responsiveness of a system to execute any action within a given time interval. It can be measured in terms of latency or throughput. Latency is the time taken to respond to any event. Throughput is the number of events that take place within a given amount of time.

• Reliability. Reliability is the ability of a system to remain operational over time. Reliability is measured as the probability that a system will not fail to perform its intended functions over a specified time interval.

• Reusability. Reusability is the capability for components and subsystems to be suitable for use in other applications and in other scenarios. Reusability minimizes the duplication of components and also the implementation time.

• Scalability . Scalability is the ability of a system to function well when there are changes to the load or demand. Typically, the system will be able to be extended over more powerful or more numerous servers as demand and load increase.

• Security. Security is the ways that a system is protected from disclosure or loss of information, and the possibility of a successful malicious attack. A secure system aims to protect assets and prevent unauthorized modification of information.

• Supportability. Supportability is how easy it is for operators, developers, and users to understand and use the application, and how easy it is to resolve errors when the system fails to work correctly.

• Testability. Testability is a measure of how easy it is to create test criteria for the system and its components, and to execute these tests in order to determine if the criteria are met. Good testability makes it more likely that faults in a system can be isolated in a timely and effective manner.

• Usability. Usability defines how well the application meets the requirements of the user and consumer by being intuitive, easy to localize and globalize, and able to provide good access for disabled users and a good overall user experience.

 

 

Layered Architecture Reference Model

Figure 3 shows our canonical application example. It’s a layered architecture showing the common components within each layer: The canonical application model helped us show how the various layers and components work together. It was an easy diagram to pull up and talk through when we were discussing various design trade-offs at the different layers.

 

Figure 3: Layered Architecture Model

 

Layers

We identified the following layers:

• Presentation layer

• Business layer

• Data layer

• Service layer

They are logical layers. The important thing about layers is that they help factor and group your logic. They are also fractal. For example, a service can have multiple types of layers within it. The following is a quick explanation of the key components within each layer.

Presentation Layer Components

• User interface (UI) components. UI components provide a way for users to interact with the application. They render and format data for users and acquire and validate data input by the user.

• User process components. To help synchronize and orchestrate these user interactions, it can be useful to drive the process by using separate user process components. This means that the process-flow and state-management logic is not hard-coded in the UI elements themselves, and the same basic user interaction patterns can be reused by multiple UIs.

Business Layer Components

• Application facade (optional). Use a façade to combine multiple business operations into a single message-based operation. You might access the application façade from the presentation layer by using different communication technologies.

• Business components. Business components implement the business logic of the application. Regardless of whether a business process consists of a single step or an orchestrated workflow, your application will probably require components that implement business rules and perform business tasks.

• Business entity components. Business entities are used to pass data between components. The data represents real-world business entities, such as products and orders. The business entities used internally in the application are usually data structures, such as DataSets, DataReaders, or Extensible Markup Language (XML) streams, but they can also be implemented by using custom object-oriented classes that represent the real-world entities your application has to work with, such as a product or an order.

• Business workflows. Many business processes involve multiple steps that must be performed in the correct order and orchestrated. Business workflows define and coordinate long-running, multi-step business processes, and can be implemented using business process management tools.

Data Layer Components

• Data access logic components. Data access components abstract the logic necessary to access your underlying data stores. Doing so centralizes data access functionality, and makes the process easier to configure and maintain.

• Data helpers / utility components. Helper functions and utilities assist in data manipulation, data transformation, and data access within the layer. They consist of specialized libraries and/or custom routines especially designed to maximize data access performance and reduce the development requirements of the logic components and the service agent parts of the layer.

• Service agents. Service agents isolate your application from the idiosyncrasies of calling diverse services from your application, and can provide additional services such as basic mapping between the format of the data exposed by the service and the format your application requires.

Service Layer Components

• Service interfaces. Services expose a service interface to which all inbound messages are sent. The definition of the set of messages that must be exchanged with a service, in order for the service to perform a specific business task, constitutes a contract. You can think of a service interface as a façade that exposes the business logic implemented in the service to potential consumers.

• Message types. When exchanging data across the service layer, data structures are wrapped by message structures that support different types of operations. For example, you might have a Command message, a Document message, or another type of message. These message types are the “message contracts” for communication between service consumers and providers.

 

 

Tiers

Tiers represent the physical separation of the presentation, business, services, and data functionality of your design across separate computers and systems. Some common tiered design patterns include two-tier, three-tier, and n-tier.

Two-Tier

The two-tier pattern represents a basic structure with two main components, a client and a server (Figure 4).

 

Figure 4: Two-Tier Deployment

 

Three-Tier

In a three-tier design, the client interacts with application software deployed on a separate server, and the application server interacts with a database that is also located on a separate server (Figure 5). This is a very common pattern for most Web applications and Web services.

 

Figure 5: Three-Tier Deployment

 

N-Tier

In this scenario, the Web server (which contains the presentation layer logic) is physically separated from the application server that implements the business logic (Figure 6).

 

Figure 6: N-Tier Deployment

 

 

Conclusion

It’s easier to find your way around when you have a map. By having a map, you know where the key hot spots are. The map helps you organize and share relevant information more effectively. More importantly, the map helps bring together archetypes, arch styles, and hot spots in a meaningful way. When you put it all together, you have a simple language for describing large classes of applications, as well as a common language for application architecture.

 

 

Switching IT Outsourcing Vendors

Organizations invariably spend a considerable amount of time and money before entering into contracts with IT service providers and the negotiations are typically long drawn. Having thus invested in the process of selecting vendors, many organizations shy away from ousting IT suppliers once the contract is underway. And in most cases, once the contract has terminated, the incumbent IT provider is awarded an extension so as to avoid the pains of choosing a new supplier.

However, in the recent past there have been a number of cases where customers have either terminated a contract or switched suppliers post-termination. Deals to the tune of over $1.5 bn have seen acrimonious splits over pricing issues and in another case a customer dropped its IT provider to replace it with the incumbent supplier of its newly acquired arm.

Needless to say these decisions to switch vendors have always been a well thought over one. These decisions need to incorporate the base understanding and benefit rationalization of switching to a new vendor. For this, the customers need to well aware of the risks involved in changing suppliers, either mid-contract or post-termination. Once the risks are identified, they can be tackled with a certain amount of visibility into the future in conjunction with a thorough analysis of the existing conditions which gives a clear picture to the customer, on the cause and effects of the switching decision.


Need for switching vendors

Customers have switched IT providers for reasons as varied as pricing issues to nonperformance
on service levels to cultural nonalignment of organizations. At a broad level, the key
factors that act as a catalyst and hasten the switching of IT providers can be clubbed into the
following categories

• Customer Landscape Changes: The customer may be ready to move up its value ladder and hence may have outgrown the vendor. In some cases, the customer could find the regional vendor unable to service their global needs. Or in some cases, customers may feel that handing off operations to a contractor makes it the outsourcing customer less nimbleand may seek to regain control of its operations.

• Vendor Market Changes: Once a contract iswell underway, customers may realize that the vendor market has expanded and there are more players now who can help them build competitive advantage.

• Vendor Rationalization: In most cases, as a means of diversifying risk, outsourcing customers divide their portfolio among multiple vendors. As a result, certain customers experience a loss of purchasing power. In a bid to regain some of this purchasing power, customers may look to reduce the number of vendors. This may necessitate transitioning certain outsourced functions from one vendor to another existing one.

• Relationship/Performance Issues: In many cases, the vendor may fall short of the
  expectations of the outsourcing engagement. A survey from Benchmark Research
  found that outsourcing clients have experienced significant problems in managing
  their post-contractual relationships. This can arise because of multiple causes:
  
  • Unrealistic expectation setting prior to before signing the contract
  • Vendor not meeting service level agreements that are part of the contract
  • The vendor may actually be delivering on the service agreements but the
  • client sees less value than expected.

For any of these reasons, the customer may choose to change the supplier and go with a new player. However, such customers need to be aware of the risks that may affect the entire process of transitioning to the new vendor.


Risks in switching vendors

Switching from one outsourcing vendor to another mid-contract involves the effort and risk of both terminating and entering into an outsourcing agreement. Switching vendors can be costly, considering the employee time and effort for transition, and the legal and consulting fees as well.
Some of the costs and risks in changing vendors are:

• Knowledge Transition A key risk in changing vendors is ineffective knowledge transition between the incumbent vendor and the new vendor(s). While this risk has a lower impact in the case of switching vendors post-contract termination, in the scenario of changing vendors mid-contract this can be a serious concern. Effort must be taken to ensure that complete and effective knowledge transition happens between all the vendor parties involved.

• Knowledge Stickiness The problem of stickiness is not peculiar to a scenario of changing vendors but is more a issue in knowledge transfer. However it merits separate mention because in the case of switching suppliers, the risk of stickiness is magnified.
  Stickiness is the core characteristic of specialized, personal and tacit knowledge that inhibits easy transfer. Some of the origins of stickiness are strained relationships, lack of motivation on the part of the source, lack of absorptive capacity of the recipient and the extent of knowledge that is tacit. All of these factors need to be dealt with when switching vendors midway during an engagement.

• Business Disruption Risk If the customer is seeking to change vendors at the end of a contract, they would factor in the time required to get a new vendor on board so as to prevent disruption of business. However in case of mid-contract termination, the customer has to ensure that moving from one vendor to the other does not disrupt the business. The transition between vendors, even in a hostile scenario, has to be managed in a way that lets the business proceed as usual.

• Organizational Alignment Risks Changing a vendor in the course of a project requires the customer organization to work with a new vendor. Such changes are usually met with resistance in many organizations and needs to be resolved by the customer organization and the new vendor working together.

• Costs of exiting the current sourcing contract In the absence of a reversibility clause, the legal and consultancy charges could turn out to be huge for the client and can be a bottleneck for a smooth transition to a new vendor. These termination charges and unwind costs are a key consideration before taking the call for a new vendor.

Once the customer is aware of the costs and risks involved in switching IT vendors, the customer can take a call on the approach that needs to be adopted in changing vendors.



Approaches to Switching Vendors

Depending upon the context in which the vendor replacement occurs, there can be the different approaches to switching vendors. At one extreme is the scenario of a hostile transition from one vendor to another in the course of an ongoing engagement entailing compressed timelines. At the other extreme is the case of end-of-contract mutually-agreedon transition from one supplier to the other. This would allow the luxury of detailed transition, over longer time lines. Depending on such scenarios the following are some of the approaches that may be chosen:

• The Big Bang Approach
  
  In case a hostile vendor transition seems a possibility, companies opt for a big bang approach to facilitate a quick transition, especially in business critical engagements.
  
  The project time line is charted out keeping in mind the lack of co-operation the existing vendor may exhibit. Since there are chances that the current vendor shall be reticent in participating in the transition process, it is critical that all key stakeholders of client are taken into confidence.
  
  After having explored the possibility of poaching resources from the existing vendor the changeover is done in a short time span, leaving minimal chance for any planned hostility by the existing vendor. The incumbent vendor may initiate ways and means to prevent a smooth transition by trying to dismiss or transfer key stakeholders and developers to another project which might lead to the loss of important information –the new vendor and the customer need to be prepared for such an eventuality.

• The Phased Approach
  
  In the phased approach of new vendor transition the most business critical processes
  are transitioned on a priority.
  
  The customer chooses to transition in a phase wise manner, in which controls from the existing vendor and deliverables of the same are gradually taken over by the new vendor. Initially only the base subset of necessary operations is transitioned to the new vendor and the rest are gradually taken over depending on the priority of the processes and their business impacts.
  
  Given the time frame that this transition requires, it is imperative that the transition
  requires co-operation between the outgoing vendor and the new vendor.

Given these different approaches, the customer needs to make the right choice as to which approach is best suited for its current situation. The choice of the approach depends not only on the extent of co-operation that may be possible between the customer, the incumbent vendor and the new vendor, but also on the strategic importance of the functions being transferred.

For instance, if the functions that need to be transferred are business critical and there is a possibility that the co-operation from the incumbent vendor may not be complete, the customer may be better off using the Big Bang approach rather than using a Phased approach. This stems from the reasoning that the customer may want to get the functions transferred immediately and avoid any business disruption – opting for a Phased approach may result in delays in implementation owing to lack of co-operation, thus affecting the business continuity.


Recommended Framework for Transitioning

When switching vendors, the customer has to first decide the approach that is to be adopted and once that decision is made, the customer along with the new vendor must embark on getting the knowledge transferred from the incumbent to the new vendor. This does not pose an issue in the case of a mutually agreed upon, end-of-contract vendor switching scenario where total co-operation of the incumbent vendor can be expected. However, in cases where the co-operation from the incumbent is unlikely to be complete, transitioning can be tricky. In such scenarios, the customer, in tandem with the new vendor, must ensure that all required know-how is obtained from the incumbent vendo before the vendor exits.

Customers may choose to go about this process in different ways, depending on the exact scenario that exists. Described below is a recommended, 5-step framework, Analyze-Build Portfolio-Architect-Transition-Execute (ABATE), for transitioning, especially suited for cases where full co-operation from the incumbent cannot be expected.

• Analyze
  The new vendor must thoroughly analyze the current scenario and the customer vendor dynamics. This helps the new vendor understand the context, and the situation of the customer as well as that of the existing vendor.
  
  The new vendor must understand the reason the customer cites for switching vendors in a mid-contract situation. Getting an insight into these reasons would help in drawing up a comprehensive contract with the customer so as to prevent similar distasteful situations later on, once the contract is in place.
  

• Build Portfolio
  With an understanding of the ground situation from the earlier stage, the new vendor, along with the customer, must build a portfolio of the functions that need to be transferred from the incumbent vendor. This is critical as it determines the scope of the new contract that will be inked. In cases where the switching of vendors is taken up mid-engagement, the new vendor would also need to capture the exact state in which the different projects of the engagement are.
  
  As part of the portfolio building exercise, the new vendor, in conjunction with the customer, must also prioritize the different functions that need to be transferred. This prioritization must take into account parameters like the business criticality of the function and the state of the project.
  
  At this stage, the customer and the new vendor must also create a repository of all the project related documentation that can be obtained from the incumbent as this will help reduce the time required for transition.
  
  These details, along with the results of the analysis stage, would contribute to the contract that would be created between the new vendor and the customer.

• Architect
  The next step in the process is to create a contract between the new supplier and the customer. This new contract must be exhaustive and must imbibe lessons from the customer’s prior experience with the incumbent. The new vendor must aid the customer in drawing up a contract that has mutually beneficial safe guards for both sides.

• Transition
  Once the contract is in place, the next step is the actual transitioning of the knowledge from the incumbent to the new supplier. Ideally this phase would require certain degree of co-operation from the incumbent. In cases where there is low cooperation from the incumbent, the onus is on the vendor and the customer to ensure that sufficient know-how is gathered from the incumbent that will allow the new vendor to take over the functions.
  
  The new vendor can consider measures like employing project members from the incumbent vendor team, shadowing customer SMEs, use of checklists, scientific
  knowledge transfer processes, setting up knowledge repositories and continuous monitoring to ensure that all required know how is obtained before the incumbent
  vendor exits.
  

• Execute
  The last step in the process is the execution phase where the business processes outsourced are transitioned from the existing vendor to the new vendor. Metrics are
  defined in conjunction with the customer and these are monitored against the service
  level agreements set up in step 3 to ensure that the engagement is on track.

Transition Checklist

As part of the entire switching process there are a series of practices that the new vendor and the customer can adopt to ensure successful transitioning. Some of these are as follows:

• “Poaching” – The customer must examine its contract with the incumbent and if this does not restrain it from hiring the vendor employees, the customer must identify key vendor resources and get them on board. In some cases, the customer may be inhibited by contractual agreements from directly hiring the incumbent supplier employees. In these cases, the new vendor can step in and employ few important team members from the incumbent supplier organization so as to ensure knowledge continuity

• Infrastructure Set Up – The customer has to ensure that the right infrastructure set up is in place to allow for a fast and efficient transition from the incumbent to the new vendor. Unavailability of critical requirements like network access or communication links at this stage can set the schedule back by a fair extent. In cases where the incumbent vendor is not fully supportive and its exit date is non-negotiable, such a delay can derail the entire transition effort.
  

• Data touch points and Documentation – Important documentation like the manuals, data on the client systems, as well as the architecture standards for the customer’s environment etc should be obtained from the incumbent. The customer must help to identify and catalogue any such documentation that may exist. The complete repository of such documentation and other such system interdependencies are extremely useful for a successful transition to the new vendor.

• Secure Incumbent buy-in – The customer must take all possible steps to secure cooperation from the incumbent vendor for the transition. This could involve different
  measures like ensuring incumbent participation through exit clauses in the contract or
  putting in place incentives for the incumbent resources to be part of the transition.

• Debriefing – The customer must help identify the key resources who worked with the
  incumbent vendor or on the vendor’s application so as to get full details of the functions outsourced. The new vendor can then have detailed discussions with these key resources so as to fill in any gaps in the knowledge transitioned.

• Scientific Inputs to selecting resources – Many a time, customers make the error of
  assuming that resources who have spent more time in a function or on an application are the SMEs for that function/application. This has been proven to be erroneous and the new vendor must educate the customer that long term experience does not always mean increasing expertise. Ignoring this, may result in the new vendor spending time
  with customer personnel who may not be the key resources.

• Address Learning Styles – The customer must ensure that the new vendor is using
  the available team effectively during the transition phase.
  Different team members have different learning styles and recognizing this can help channel their efforts better. For example, identifying the “Accommodators” in the team and putting them onto trial fixes and enhancements while using “Divergers” for Application Demos would be better than sending the first group for Demos and assigning trail runs to the second.

• Transferring Software licenses – The customer along with the new vendor must identify the software that are required to be in place for the new vendor to take up the outsourced function and the rights of these must be transferred from the incumbent supplier to the new vendor, if the contract allows for this.

The above mentioned is not an exhaustive list since every scenario involving a change of vendors is different & unique. Hence, for some transitions this checklist may not suffice or be mapped to directly. The customer and the new vendor must work jointly to mitigate all the risks that may be posed by the change of suppliers and by having in place processes and systems like the framework described above, the transition can be made seamless and smooth.



Symbyo Framework in action

Symbyo has worked on a number of engagements where we replaced incumbent vendors – both mid-contract and also post-contract termination. In all of these engagements Symbyo successfully transitioned from the incumbent with minimal disruption of services to the customer.

HOW SYMBYO USE THE ABATE FRAMEWORK
The entire transition from an outgoing vendor to symbyo is done in an accelerated manner to meet the project deadlines.

• Analyze
  Timelines: Day 1 – Day 2
  
  A team from Symbyo meet with the customer and over a series of discussions analyzed the ground scenario. The team also meet with key members of the outgoing team to get their perspective of the situation. The inputs from these meetings are instrumental in determining the course of the project.
  

• Build Portfolio
  Timelines: Day 1 – Day 3
  
  TDuring these two days, Symbyo in conjunction with the customer prepare a list of functions and services that have to be transitioned from the incumbent vendor within the 2 week time frame.
  
  A detailed list of documents and artifacts that would help in transition is prepared and the customer take on the responsibility of obtaining these from the incumbent.
  

• Architect
  Timelines: Day 4 – Day 5
  
  With inputs from the previous two phases, the customer and Symbyo prepare a contract for the new relationship. This contract has in place exit clauses and other practices that were not followed in the earlier contract the customer had with the incumbent.
  

• Transition
  Timelines: Day 6 – Day 10
  
  This phase covers both the planning for transition and the actual transition.
  
  A comprehensive transition plan, spanning the transition of all components, is developed by Symbyo in collaboration with the client. This plan also detailed the transition process, roles, resources, task break up and timelines set up in collaboration with the client. The KT planning stage covers the following:

• Discussing and defining training inventory and schedule
• Pre-requisite skill set for Symbyo’s resources
• Quality control measures to track the status of KT

• Once the planning was completed and the plan was signed off by the customer and Symbyo, the actual transition was kicked off. The following are key highlights of the transition phase

• Transition properly planned and divided into different phases with Checkpoints in each phase, and clear deliverables. The different phases included

• Environment Setup
• Business Overview
• Technical Overview
• Database Overview
  

• The different components of the KT are

• Technical Environment Training for familiarization to technical
  environment, inventory collection, tools, utilities, commands etc.
• Business Training which consisted of business overview and functionality discussions for each business functionality and interfaces, user procedures and product training.
• Techno-Business or Application Training where technical sessions for business concepts were conducted.

• Formal documented transition sessions are organized involving vendor and Symbyo team with pre-decided daily and weekly deliverables.

• The system documents were updated and validated to ensure accurate knowledge transfer.

• Reverse presentations were made to the client at the end of each day. This ensured that the data/info provided by the contractors was validated and the gaps were identified and addressed at very early stages.

• Execute
  Timelines: Day 10 – End of engagement
  
  Post-transition, Symbyo completely replaced the incumbent and took full ownership of the outsourced function. Metrics were continually collected and analyzed to ensure that the terms laid out in the SLA were met. Once steady state was achieved, Symbyinitiated process improvement measures that helped deliver greater benefits to the client.
  

In the final analysis:

Switching vendors is a reality in the IT services domain and therefore it deems fit that, sooner clients and vendors take of this fact and prepares to tackle it, the better.

Customers need to understand the different risks that can affect their business as a result of inefficient vendor switching. The customer must also decide on the best approach that needs to be taken to go about the transition. This decision must take into consideration the strategic importance of the functions in balance and the extent of co-operation that can be expected between the customer, the incumbent vendor and the new supplier. The new vendor has a key role to play in the entire process – right from helping the customer in exiting the relation with the incumbent to forming the new contract. The new vendor also has the responsibility of helping capture the know how from the incumbent, using the best practices for the same.

Customers need to understand that switching vendors is not an easy task; it is daunting and tiresome. But at the same time, they must realize that it is not an impossible task. With proper planning and analysis, and backed by a strong vendor, the customer can certainly exit from an engagement with the incumbent and partner with the new vendor with no impact on the business.

Application Outsourcing Services

In tough economic times, businesses have three choices: ignore the situation, accept defeat, or take control. The first two options—doing nothing and riding out the storm or accepting the pounding—can be paralyzing, with devastating consequences. However, by taking control, businesses can stay ahead of competitors, grow market share, and ensure viability in all types of market conditions.

One way to take control is to consider all your options when it comes to your people, your processes, and your technologies. How can you make your people more productive? How can you streamline your business processes to minimize mistakes and maximize efficiency? And what technologies can help you achieve those goals quickly and cost-effectively?

With the evolution of Application Outsourcing services, companies have new choices when it comes to technologies, along with unprecedented opportunities. Instead of buying and setting up an extensive IT infrastructure—servers, networks, security, and licensed software, along with a staff to manage it all—customers who choose to outsourcing there applications management function of their IT department to a Software Outsourcing Company like Symbyo . And instead of the headaches associated with upgrades and new releases, customers simply decide which new features they want to use and take care of all the details. It’s all part of the larger picture of cloud computing pioneered by consumer companies such as Amazon.com and Google, in which people use the computing resources of other companies for their own purposes.

Symbyo Technologies is a pioneer in making this business model available to business users as well.

One of the advantages of cloud computing is that companies can focus on what they do best and on what gives them the most value for the smallest investment. Taking advantage of the cloud is one way to take control because it supports the following basic approaches. These approaches are always important to business success—and in difficult economic times, they’re critical.
:: Executing on business goals in a way that achieves revenue growth, while lowering costs and minimizing risk.
:: A strong commitment to supporting existing customers to expand the user base, ensure loyalty, and turn customers into advocates.
:: Smart and rigorous financial investments that focus on getting up and running quickly, with solutions that are flexible, support managers in making critical decisions, and make life easy for end users.

Within these approaches, there are key strategies for doing more with less, for empowering customers and partners, and for increasing the effectiveness of internal resources such as IT, sales, marketing, and customer service. This article explores how can support these strategies and how companies like yours have used Application Outsourcing to not only survive, but to thrive.