Azure Integration: 1 – Azure Logic Apps an Introduction

Logic Apps are part of Azure Integration collection. Azure integration is a collection of various Azure tools and frameworks that addresses all integration needs for an Enterprise. Logic Apps are used for core workflow processing. Service bus is Microsoft’s cloud-based queuing mechanism. It provides a durable queuing infrastructure that is highly scalable. Event grid is Azure’s event processing system. It provides near real-time eventing to many events inside Azure. API Management is used to safeguard and secure both internal and external APIs. Azure integration is functions are a lightweight streamlined unit of work that can be used to perform specific tasks. Using the on-premise Data Gateway, Logic Apps can seamlessly call into your on-premise systems. The on-premises Data Gateway has support for many systems including on-premise SQL server, SharePoint, SAP, IBM DB2, as well as BizTalk Server. The on-premises Data Gateway can even be used to monitor a local filesystem. This blog addresses Logic Apps only.

Logic Apps Advantages

  • Logic Apps is a serverless platform which means is you don’t have to worry about the management of those servers.
    • Auto-Scaling: You simply deploy your resources and the framework will ensure it gets deployed to the correct environments. You also have auto scaling based on demand. Unlike building out a SQL Azure database where you must specify a resource size, when you need more resources for your Logic Apps, they will automatically be provisioned by the platform and your solution will auto scale to meet your demand. Along with this is high availability. This is just built into the platform.
    • Use-based billing. What this means is you only pay for the resources that you use.
  • Easy to learn as Logic Apps provides a drag and drop developer experience.
  • 200+ different connectors for integration with PAAS and SAAS offerings, and on-premise systems. This suite of connectors is constantly growing and expanding. Including Enterprise connectors for systems like IBM, MQ, and SAP. In addition to support for AS2, X12, and EDIFACT messaging.
  • Ability to create custom connectors around APIs, so you can provide a custom development experience for your developers.
  • Monitoring and logging right out of the box. It is built right into the framework and accessible via the Azure Portal.
  • Seamless integration with other Azure features. This provides a rapid development experience for integrating with service bus, Azure functions, custom APIs, and more.
  • It’s easy and extremely powerful.
  • Logic Apps are very good at connecting cloud-based systems, bridging connections from on-premise systems to the cloud and vice versa. Azure Integration and Hybrid Solutions

Design and Development of Logic Apps

You have two options for building our Logic Apps:

  • The web-based designer is a simple convenient option that hosts the designer right inside the Azure portal. This designer is feature-rich and allows you to author your Logic Apps very quickly. One of the big benefits of the web-based designer is it’s very easy to test your Logic Apps because they’re already sitting out there inside your Azure subscription. The web-based designer works great for building short Logic Apps or doing proof of concepts.
  • There’s also a designer a plug-in that supports Visual Studio. The Visual Studio plug-in is a great choice for authoring Enterprise-grade Logic apps. However, you will need to deploy them into an Azure subscription to run them.

There are a couple different deployment options. Inside the web designer, you can clone your Logic App, and you can move them to other resource groups, and even other Azure subscriptions. If you’re using the Visual Studio Designer, you can create an Azure Resource Management, or ARM, template. With the ARM template, you can then use PowerShell to deploy your Logic Apps into your Azure subscription. Using the ARM templates in PowerShell, it’s very simple to deploy your Logic Apps into multiple Azure subscriptions. This makes it easy for rolling out Logic Apps to multiple environments. Another benefit of the ARM templates is that they can be checked into source control.

Connectors

Connectors are pre-built, Microsoft managed wrappers around APIs to greatly simplify interaction with those systems Connections contain environment-specific details that a connector uses for connecting to a data source including destination and authentication details. Connections live at the Resource Group level. Connectors show up inside the Azure portal underneath the segment called API connections. Under API connections, you will see all of your individual API connections that you have created inside of that Resource Group. Connections can be created using PowerShell or using the web or Visual Studio Designer. The connections that you create for your connectors can be independently managed outside of your Logic Apps. You can go under API connections inside the Azure Portal and edit connection information. You will also see your connections show up underneath your Logic App. The connections that you create for your connectors can be shared across multiple Logic Apps.

Triggers

Now let’s talk about the different ways that we can start a new instance of a Logic App. Triggers are used to initiate a Logic App. Triggers can be broken down into two main types, reactive and proactive.

  • Recurrence trigger, you specify a time interval in which that Logic App will execute.
  • Polling-based triggers., you specify a polling interval in which the Logic App will wake up and look for new work to do based on the connector that you’re using for the trigger.
  • Event-based which the Logic App can be triggered off of events that happen inside of Azure.
  • TTP and webhook triggers, so inbound HTTP requests can start your Logic Apps.
  • You can write custom API apps and use them as triggers for your Logic Apps as well.

Actions

Actions are the building blocks of Logic Apps. Most actions are also connectors. There are a few different ways to add new actions to a Logic App. The first way is at the end of the Logic App. Underneath all the other actions you will see a button to add a new step. If you click this button, you will be able to add a new action. If you are working with actions like the scope or condition action, you have the ability to add additional actions inside them. At the bottom of that action, you will see an add action button. The last way to add a new action inside a Logic App is in between two existing actions. Simply hover between the existing actions, and a plus will show up. Click on the plus and you will have the ability to add an action in between the two existing ones. Once you add a new action, the add action dialog box will pop up. This will give you the ability to search connectors and actions to find what you’re looking for. You can also narrow it down by selecting All, Built-in, Connectors, Enterprise, or Custom. This will display all the connectors that are available. When you click on a connector, it will list all available actions that are supported by that connector. Most connectors have more than one action. If you do not select a connector, you can simply select actions in the Actions selection menu and scroll through all available actions. There’s a lot of actions available to you. Since there’s so many actions available to you, it’s highly recommended to select the connector first and then see the list of available actions for that connector

Flow Control

Flow control is used to control the sequence of logic through a Logic App. All flow control actions are listed under control.

  • The if-then logic is very popular. It is used to supply a condition and then if that condition evaluates to true executes certain logic, if it evaluates to false, you would execute different logic. Inside the Logic App Designer, you have a rich condition editor where you can add multiple parameters to a single condition. You could also switch to advanced mode and edit this in JSON if you need more control over your condition.
  • Switch allows you to choose on a value and have multiple cases based on that value. There’s also a default case if none of the matching cases evaluate to true.
  • For-each allows you to loop around an array. Any array in preceding actions are available for selection for your for-each. You simply select your array in the select an output from a previous step text box, and it will automatically loop over those elements. One thing to point out about the for-each inside a Logic App is that the default behavior is to run in parallel. So by default, the Logic App will execute 20 concurrent calls to your for-each, looping around your array elements. To change this behavior, you would simply click on the … on the right side and go to settings. Underneath settings, you would select override default, and here you can change the degree of parallelism. You would simply slide it all the way down to the left to 1 if you want it done to run in sequence. This supports up to a maximum of 50 concurrent executions.
  • Do until. This allows you to select a condition to evaluate and loop around a set of actions until that condition is true.
  • Scope actions can also be used inside a Logic App. The scope action allows you to group multiple actions together and then have evaluations done on the results of the group of actions as a whole. This can be useful if you want to ensure multiple steps are successful before you continue on in a Logic App. The scope shapes will return the results of every action inside that scope as an array.
  • Terminate allows you to end the execution of your Logic App based on conditions you define in your workflow. When you add the terminate action to your Logic App, you can set the status. You can set the status to either failed, canceled, or succeeded. You can also set the error code and the error message for while you’re terminating your Logic App.

MuleSoft: Coding Standards

Establishing coding standards is essential for successful implementation of a program. The smooth functioning of software programs is vital for the success of most organizations. Coding standards are a series of procedure for a specific programming language that determines the programming style, procedures, methods, for various aspects of the program written in that language. A coding standard ensures that all developers writing the code in a language write according to the guidelines specified. This makes the code easy to understand and provides consistency in the code. The completed source code should indicate as if the code has been written by a single developer in a single session. In the following sections I provide a sample coding standard for MuleSoft code. Please let me know your thoughts by email Moustafa@MoustafaRefaat.com or through the comments.

Guiding principles

This section contains some general rules and guidance integration development should follow. Any deviations from the standard practices must be discussed with, and validated by, the technical lead on the project. This list is not intended to be exhaustive and may be supplemented during the life of the project:

    • Client first: The code must meet requirements. The solution must be cost-effective.
    • The code must be as readable as possible.
    • The code must be as simple as possible.
    • The code should reasonably isolate code that can be reused.
    • Use common design patterns where applicable.
    • Reuse a library instead of rolling your own solution to an already-solved problem.
    • Do ask if you are unsure of anything.
    • Do ensure that any modifications to the design or architecture are thought-through, well-designed and conform to n-tier architecture design principles (https://en.wikipedia.org/wiki/Multitier_architecture ).
    • Do reach out to authors of work items if alternative approaches exist for a given requirement, or if you have any concerns about any assigned work items, e.g. missing acceptance criteria.
    • Do avoid duplication of code.
    • Do add any objects that have been modified to version control as soon as possible.
    • Do alert responsible team members as to any issues or defects that you may discover while executing unrelated work items.
    • Don’t add code to troubleshoot or rectify a defect in any environment other than the development environment.

General

  • All mule elements supporting the “name” attribute for object reference should be camel case starting with a lowercase letter.
  • For mule elements that support the “Notes” section, write comments describing the purpose, functionality etc., as if you would write comments in a Java/Scala/C#/ Python function or method definition.
  • Breakup flows into separate flows or sub flows which:
    • Makes the graphical view more intuitive
    • Makes XML code easier to read
    • Enables code reuse through the reuse of flows /sub-flows
    • Provides separation between an interface and implementation
    • Easier to test
  • Always define Error handling for all flows.
  • Encapsulate global elements in a configuration file.
  • Create multiple applications, separated by functionality.
  • If deployment is on premises use a domain project to share global configuration elements between applications, which helps with:
    • Consistency between applications.
    • Expose multiple services within the domain on the same port.
    • Share the. Connection to persistent storage.
    • Utilize VM connector for communications between applications.
  • Use Application properties to provide easier way to manage configurations for different environments.
  • Create a YAML properties file the “src/main/resources” folder “{env}-config.yaml”.
  • Define Metadata in “src/main/resources/application-types.xml” for all canonical schemas, all connectors that do not create the metadata automatically.

MuleSoft Development Standards for Project Naming Convention

  • SystemAPI Apps: {source}sapi
  • ProcessAPI Apps: {process}papi
  • ExperienceAPI Apps – {Web/Mobile/Machine}eapi
  • Integration APPs – {sourceSystem}and{targetSystem}int == These are batch/or scheduled integrations

    Note that: Not all implementations would have all these types of projects.

MuleSoft Development Standards for Transformations/ DataWeave

  • Write comments.
  • Keep the code simple.
  • Provide sample data for various scenarios to test the transformation with.
  • Define a utility.dwl that stores all the common dataweave functions such as common currency, time, string conversions.
  • Save the code in an external DWL file in the src/main/resources folder for complex transformations should be stored in external DWLs (as its performance intensive).
  • Use of Dataweave libraries before writing your own dataweave functions.

MuleSoft Development Standards for Flows

  • Minimize flow complexity to improve performance.
  • Each variable defined in the flow is used by the process.
  • Transactions are used appropriately.
  • All calls to external components are wrapped in an exception-handling Scope.
  • No DataWeave contains an excessive amount of code that could alternately be included in an external component.
  • All Loops have clearly defined exit conditions.
  • All variables are explicitly instantiated.
  • All Flows has trace points inserted to enable debugging in later environments.

MuleSoft Leading Practices for Deployment and Administration

Figure 1: Continuous Integration and Continuous Deployment

Utilize Anypoint platform support for CI/CD using

  • The Mule Maven plugin to automate building, packaging and deployment of Mule Applications.
  • The MUnit Maven plugin to automate test execution.

MuleSoft Leading Practices for Testing

  • It is recommended to have the following test cycles before deployment into the production environment:
    • Unit testing the artifacts (build phase). Build MUnit Tests for all flows
    • End-to-end integration testing (SIT)
    • User acceptance testing (UAT)
    • Performance testing
  • Before deployment the solution should have been successfully tested while running under user accounts with permissions identical to the production environment.
  • Messages are validated against their schema as per the use case requirements.
  • At a minimum, the developer should conduct development unit tests & end-to-end system integration tests for every interface before certifying the interface ready for release for the QA phase of testing.

MuleSoft: Designing Integration Applications Wisdom

In this blog I will go through best practices for design integration applications. Wisdom that I have garnered through projects, MuleSoft recommendations, reviews of MuleSoft project and discussions with MuleSoft specialists.

General

  • Connector retry/Until successful/retry APIs should be present for all connections / connectors. This is an obvious one networks, and the internet have occasional disconnections. So you should always retry a few times before giving up and abandoning the operation.
  • High volume processes should be coupled with MuleSoft Batch framework and appropriate queuing mechanisms wherever necessary. This to make the processing faster and more reliable but be cautious about which queuing infrastructure you are using. VM queues are mostly queuing in memory which might cause out of memory issues.
  • Exceptions are logged to an agreed upon location. Best of course is to a ticketing system like ServiceNow or through regular logging and having log mentoring system like Splunk to collect the logs and issue waring. Refrain from utilizing Emails to send errors to support teams. Things get messy with emails and sometime tracking is lost.
  • Long-running processes should provide a way to inspect progress to date. Usually this is done through sending notification through a hookup API or pushing the progress to the logs. But it important to have a way to see that so far 60% of the data load has been processed
  • Processes are designed to be loosely coupled and promote reuse where possible. Adopt microservices sensibly not to small and not large.
  • Adopt the MuleSoft API-Led connectivity approach sensibly. Aha, this is a tricky and controversial one. Many novice Developers/Architects just follow the 3-layer API-Led pattern (System API, Process API, Experience API) religiously without thinking of the consequences. There are times when the three tiers are required other times you only need two tiers only. For example if the integration is a batch job that picks up files or records from a DB and push them to Salesforce. Then you only need System API Layer and Integration layer (no need for experience or process API layers). See below a summary of eh API Led Connectivity Approach.
    • System APIs should expose a canonical schema (project or domain scope) when there is an identified Canonical Schema for the project, domain, or organization scope. Do not just replicate the source system API removing any system specific complexities. I have seen implementation where the developers just replicated the source system API just removing the authentication for source system. This meant spending 1-4 weeks to develop test an API that removes Source System Authentication with another authentication system for the system API. As a Manager or from the client side why did we spend 4 weeks = 160 hrs at $200 per hour = 32K to develop something that is does not add 32K worth value and would cost us in the future to maintain. The reason we use a Middle wear like MuleSoft to implement integrations is to make it easy to replace system and reduce vendor dependencies. For example, if we are integrating Salesforce, SAP, Workday, and Shopify for example. If after say 2 years the crop decided to replace SAP with Dynamics AX. Now if the System API for SAP exposed SAP API with just minor modifications for authentication. Then the Dynamics AX system API does the same the all the process or integration applications would have to be changed and recoded. This is the main reason that Enterprise Service Bus had such a bad reputation. Because of bad implementations. As I wrote in my Book “BizTalk the Practical Course” http://www.lulu.com/shop/moustafa-refaat/biztalk-the-practical-course/paperback/product-4661215.html Yes I know this MuleSoft but theory is the same. It is like Quick Sort in C#, Java, C++, Scala, Python. You are still implementing “Quick Sort” same algorithm same theory different tool. Read the full discussion in the preview Page 35.

  • When creating a canonical schema stick to the project/domain scope and do not try to create a generic canonical schema for the whole organization.

I cannot stress this enough, while MuleSoft promotes the Three-Tire structure and Application API network, it does not always make sense to use this approach in all situations. Strive to design the integration architecture to be: –

  1. Easy to maintain
  2. As modular as possible
  3. Any components that can be reused should be isolated into its own library or application

The MuleSoft API-led connectivity approach


API-led connectivity is a methodical way to connect data to applications through a series of reusable and purposeful modern APIs that are each developed to play a specific role – unlock data from systems, compose data into processes, or deliver an experience. API-led connectivity provides an approach for connecting and exposing assets through APIs. As a result, these assets become discoverable through self-service without losing control.

  • System APIs: In the example, data from SAP, Salesforce and ecommerce systems is unlocked by putting APIs in front of them. These form a System API tier, which provides consistent, managed, and secure access to backend systems.
  • Process APIs: Then, one builds on the System APIs by combining and streamlining customer data from multiple sources into a “Customers” API (breaking down application silos). These Process APIs take core assets and combines them with some business logic to create a higher level of value. Importantly, these higher-level objects are now useful assets that can be further reused, as they are APIs themselves.
  • Experience APIs: Finally, an API is built that brings together the order status and history, delivering the data specifically needed by the Web app. These are Experience APIs that are designed specifically for consumption by a specific end-user app or device. These APIs allow app developers to quickly innovate on projects by consuming the underlying assets without having to know how the data got there. In fact, if anything changes to any of the systems of processes underneath, it may not require any changes to the app itself.

Defining the API data model

The APIs you have identified and started defining in RAML definitions exchange data representations of business concepts, mostly in JSON format. Examples are:

  • The JSON representation of the Policy Holder of a Motor Policy returned by the “Motor Policy Holder Search SAPI”
  • The XML representation of a Quote returned by the “Aggregator Quote Creation EAPI” to the Aggregator
  • The JSON representation of a Motor Quote to be created for a given Policy Holder passed to the “Motor Quote PAPI”
  • The JSON representation of any kind of Policy returned by the “Policy Search PAPI”

All data types that appear in an API (i.e., the interface) form the API data model of that API. The API data model should be specified in the RAML definition of the API. API data models are clearly visible across the application network because they form an important part of the interface contract for each API.

The API data model is conceptually clearly separate from similar models that may be used inside the API implementation, such as an object-oriented or functional domain model, and/or the persistent data model (database schema) used by the API implementation. Only the API data model is visible to API clients in particular and to the application network in general – all other forms of models are not. Consequently, only the API data model is the subject of this discussion.

Enterprise Data Model versus Bounded Context Data Models

The data types in the API data models of different APIs can be more or less coordinated:

  • In an Enterprise Data Model – often called Canonical Data Model, but the discussion here uses the term Enterprise Data Model throughout – there is exactly one canonical definition of each data type, which is reused in all APIs that require that data type, within all of Acme Insurance
  • E.g., one definition of Policy that is used in APIs related to Motor Claims, Home Claims, Motor Underwriting, Home Underwriting, etc.
  • In a Bounded Context Data Model several Bounded Contexts are identified within Acme Insurance by their usage of common terminology and concepts. Each Bounded Context then has its own, distinct set of data type definitions – the Bounded Context Data Model. The Bounded Context Data Models of separate Bounded Contexts are formally unrelated, although they may share some names. All APIs in a Bounded Context reuse the Bounded Context Data Model of that Bounded Context
  • E.g., the Motor Claims Bounded Context has a distinct definition of Policy that is formally unrelated to the definition of Policy in the Home Underwriting Bounded Context
  • In the extreme case, every API defines its own API data model. Put differently, every API is in a separate Bounded Context with its own Bounded Context Data Model.

Abstracting backend systems with System APIs

System APIs mediate between backend systems and Process APIs by unlocking data in these backend systems:

  • Should there be one System API per backend system or many?
  • How much of the intricacies of the backend system should be exposed in the System APIs in front of that backend system? In other words, how much to abstract from the backend system data model in the API data model of the System APIs in front of that backend system?

General guidance:

  • System APIs, like all APIs, should be defined at a granularity that makes business sense and adheres to the Single Responsibility Principle.
  • It is therefore very likely that any non-trivial backend system must be fronted by more than one System API
  • If an Enterprise Data Model is in use, then
    • the API data model of System APIs should make use of data types from that Enterprise Data Model
    • the corresponding API implementation should translate between these data types from the Enterprise Data Model and the native data model of the backend system
  • If no Enterprise Data Model is in use, then
    • each System API should be assigned to a Bounded Context, the API data model of System APIs should make use of data types from the corresponding Bounded Context Data Model
    • the corresponding API implementation should translate between these data types from the Bounded Context Data Model and the native data model of the backend system
    • In this scenario, the data types in the Bounded Context Data Model are defined purely in terms of their business characteristics and are typically not related to the native data model of the backend system. In other words, the translation effort may be significant
  • If no Enterprise Data Model is in use, and the definition of a clean Bounded Context Data Model is considered too much effort, then
    • the API data model of System APIs should make use of data types that approximately mirror those from the backend system
    • same semantics and naming as backend system
    • but for only those data types that fit the functionality of the System API in question backend system often are Big Balls of Mud that cover many distinct Bounded Contexts
    • lightly sanitized e.g., using idiomatic JSON data types and naming, correcting misspellings, …
    • expose all fields needed for the given System API’s functionality, but not significantly more ◦ making good use of REST conventions

The latter approach, i.e., exposing in System APIs an API data model that basically mirrors that of the backend system, does not provide satisfactory isolation from backend systems through the System API tier on its own. In particular, it will typically not be possible to “swap out” a backend system without significantly changing all System APIs in front of that backend system – and therefore the API implementations of all Process APIs that depend on those System APIs! This is so because it is not desirable to prolong the life of a previous backend system’s data model in the form of the API data model of System APIs that now front a new backend system. The API data models of System APIs following this approach must therefore change when the backend system is replaced. On the other hand:

  • It is a very pragmatic approach that adds comparatively little overhead over accessing the backend system directly
  • Isolates API clients from intricacies of the backend system outside the data model (protocol, authentication, connection pooling, network address, …)
  • Allows the usual API policies to be applied to System APIs
  • Makes the API data model for interacting with the backend system explicit and visible, by exposing it in the RAML definitions of the System APIs
  • Further isolation from the backend system data model does occur in the API implementations of the Process API tier

MuleSoft Application Modularization

Mule allows you to run applications side-by-side in the same instance. Each Mule application should represent a coherent set of business or technical functions and, as such, should be coded, tested, built, released, versioned and deployed as a whole. Splitting particular functions into individual applications allows a coarse-grained approach to modularity and is useful when keeping elements of your application running while others could go through some maintenance operations. For optimum modularity:

Consider what functions are tightly interrelated and keep them together in the same Mule application: they will form sub-systems of your whole solution.

  • Establish communication channels between the different Mule applications: the VM transport will not be an option here, as it can’t be used across different applications. Prefer the TCP or HTTP transports for synchronous channels and JMS for asynchronous ones

TOGAF Certification Series 7: TOGAF® 9 Certified ADM Phases E,F,G,H And Requirements Management

Chapter 9 Phase E: Opportunities & Solutions

  • The objectives of Phase E: Opportunities and Solutions are to:
    • Generate the initial complete version of the Architecture Roadmap, based upon the gap analysis and candidate Architecture Roadmap components from Phases B, C, and D
    • Determine whether an incremental approach is required, and if so identify Transition Architectures that will deliver continuous business value
  • Phase E is a collaborative effort with stakeholders required from both the business and IT sides. It should include both those that implement and those that operate the infrastructure. It should also include those responsible for strategic planning, especially for creating the Transition Architectures, if required.
  • Phase E consists of the following steps:
    • 1. Determine/confirm key corporate change attributes
    • 2. Determine business constraints for implementation
    • 3. Review and consolidate Gap Analysis results from Phases B to D
    • 4. Review consolidated requirements across related business functions
    • 5. Consolidate and reconcile interoperability requirements
    • 6. Refine and validate dependencies
    • 7. Confirm readiness and risk for business transformation
    • 8. Formulate Implementation and Migration Strategy
    • 9. Identify and group major work packages
    • 10. Identify Transition Architectures
    • 11. Create the Architecture Roadmap & Implementation and Migration Plan
  • The most significant issue to be addressed is business interoperability. Most SBBs or COTS will have their own embedded business processes. Changing the embedded business processes will often require so much work, that the advantages of re-using solutions will be lost with updates being costly and possibly requiring a complete rework. Furthermore, there may be a workflow aspect between multiple systems that has to be taken into account. The acquisition of COTS software has to be seen as a business decision that may require rework of the domain architectures. The enterprise architect will have to ensure that any change to the business interoperability requirements is signed off by the business architects and architecture sponsors in a revised Statement of Architecture Work.

Chapter 10 Phase F: Migration Planning

  • The objectives of Phase F: Migration Planning are to:
    • Finalize the Architecture Roadmap and the supporting Implementation and Migration Plan
    • Ensure that the Implementation and Migration Plan is coordinated with the enterprise’s approach to managing and implementing change in the enterprise’s overall change portfolio
    • Ensure that the business value and cost of work packages and Transition Architectures is understood by key stakeholders
  • Phase F consists of the following steps:
    • 1. Confirm management framework interactions for the Implementation and Migration Plan
    • 2. Assign a business value to each work package
    • 3. Estimate resource requirements, project timings, and availability/delivery vehicle
    • 4. Prioritize the migration projects through the conduct of a cost/benefit assessment and risk validation
    • 5. Confirm Architecture Roadmap and update Architecture Definition Document
    • 6. Complete the Implementation and Migration Plan
    • 7. Complete the architecture development cycle and document lessons learned
  • A technique to assess business value is to draw up a matrix based on a value index dimension and a risk index dimension. An example is shown in Figure 12. The value index should include criteria such as compliance to principles, financial contribution, strategic alignment, and competitive position. The risk index should include criteria such as size and complexity, technology, organizational capacity, and impact of a failure. Each criterion should be assigned an individual weight. The index and its criteria and weighting should be developed and approved by senior management. It is important to establish the decision-making criteria before the options are known.

Chapter 11 Phase G: Implementation Governance

  • The objectives of Phase G: Implementation Governance are to:
    • Ensure conformance with the Target Architecture by implementation projects
    • Perform appropriate Architecture Governance functions for the solution and any implementation-driven architecture Change Requests
  • The Architecture Contract produced in this phase features prominently in the area of Architecture Governance (see Chapter 22). It is often used as the means to driving change. In order to ensure that the Architecture Contract is effective and efficient, the following aspects of the governance framework should be introduced in this phase:
    • Simple process
    • People-centered authority
    • Strong communication
    • Timely responses and effective escalation process
    • Supporting organization structures
  • Phase G consists of the following steps:
    • Confirm scope and priorities for deployment with development management
    • Identify deployment resources and skills
    • Guide development of solutions deployment
    • Perform enterprise Architecture Compliance Reviews
    • Implement business and IT operations
    • Perform post-implementation review and close the implementation

Chapter 12 Phase H: Architecture Change Management

  • The objectives of Phase H: Architecture Change Management are to:
    • Ensure that the architecture lifecycle is maintained
    • Ensure that the Architecture Governance Framework is executed
    • Ensure that the enterprise Architecture Capability meets current requirements
  • Phase H consists of the following steps:
    • 1. Establish value realization process
    • 2. Deploy monitoring tools
    • Manage risks
    • 4. Provide analysis for architecture change management
    • 5. Develop change requirements to meet performance targets
    • 6. Manage governance process
    • 7. Activate the process to implement change

Chapter 13 ADM Architecture Requirements Management

  • The objectives of the Requirements Management phase are to:
    • Ensure that the Requirements Management process is sustained and operates for all relevant ADM phases
    • Manage architecture requirements identified during any execution of the ADM cycle or a phase
    • Ensure that relevant architecture requirements are available for use by each phase as the phase is executed

TOGAF Certification Series 6: TOGAF® 9 Certified

 

 

Chapter 2 Preliminary Phase

  • The objectives of the Preliminary Phase are to:
    • Determine the Architecture Capability desired by the organization:
      • Review the organizational context for conducting enterprise architecture
      • Identify and scope the elements of the enterprise organizations affected by the Architecture Capability
      • Identify the established frameworks, methods, and processes that intersect with the Architecture Capability
      • Establish a Capability Maturity target
    • Establish the Architecture Capability:
      • Define and establish the Organizational Model for Enterprise Architecture
      • Define and establish the detailed process and resources for architecture governance
      • Select and implement tools that support the Architecture Capability
      • Define the architecture principles
  • An Architecture Framework is a tool for assisting in the acceptance, production, use, and maintenance of architectures

 

Chapter 3 Phase A: Architecture Vision

  • The objectives of Phase A: Architecture Vision are to:
    • Develop a high-level aspirational vision of the capabilities and business value to be delivered as a result of the proposed enterprise architecture
    • Obtain approval for a Statement of Architecture Work that defines a program of works to develop and deploy the architecture outlined in the Architecture Vision
  • Phase A consists of the following steps:
    • 1. Establish the architecture project
    • 2. Identify stakeholders, concerns, and business requirements
    • 3. Confirm and elaborate business goals, business drivers, and constraints
    • 4. Evaluate business capabilities
    • 5. Assess readiness for business transformation
    • 6. Define scope
    • 7. Confirm and elaborate architecture principles, including business principles
    • 8. Develop Architecture Vision
    • 9. Define the Target Architecture value propositions and KPIs
    • 10. Identify the business transformation risks and mitigation activities
    • 11. Develop Statement of Architecture Work; secure approval

  • The outputs of this phase are:
    • Statement of Architecture Work
    • Refined statements of business principles, business goals, and business drivers
    • Architecture principles
    • Capability assessment
    • Tailored Architecture Framework
    • Architecture Vision, including:
      • Problem description
      • Objective of the Statement of Architecture Work
      • Summary views
      • Business scenario (optional)
      • Refined key high-level stakeholder requirements
    • Draft Architecture Definition Document (see Section 4.5.1), including (when in scope):
      • Baseline Business Architecture (high-level)
      • Baseline Data Architecture (high-level)
      • Baseline Application Architecture (high-level)
      • Baseline Technology Architecture (high-level)
      • Target Business Architecture (high-level)
      • Target Data Architecture (high-level)
      • Target Application Architecture (high-level)
      • Target Technology Architecture (high-level)
    • Communications Plan
    • Additional content populating the Architecture Repository

Chapter 4 Phase B: Business Architecture

  • The objectives of Phase B: Business Architecture are to:
    • Develop the Target Business Architecture that describes how the enterprise needs to operate to achieve the business goals, and respond to the strategic drivers set out in the Architecture Vision, in a way that addresses the Request for Architecture Work and stakeholder concerns
    • Identify candidate Architecture Roadmap components based upon gaps between the Baseline and Target Business Architectures
  • Phase B consists of the following steps:
    • 1. Select reference models, viewpoints, and tools
    • 2. Develop Baseline Business Architecture Description
    • 3. Develop Target Business Architecture Description
    • 4. Perform Gap Analysis
    • 5. Define candidate roadmap components
    • 6. Resolve impacts across the Architecture Landscape
    • 7. Conduct formal stakeholder review
    • 8. Finalize the Business Architecture
    • 9. Create the Architecture Definition Document

 

Chapter 5 Phase C: Information Systems Architectures

  • The objectives of Phase C: Information Systems Architectures are to:
    • Develop the Target Information Systems (Data and Application) Architectures, describing how the enterprise’s Information Systems Architecture will enable the Business Architecture and the Architecture Vision, in a way that addresses the Request for Architecture Work and stakeholder concerns
    • Identify candidate Architecture Roadmap components based upon gaps between the Baseline and Target Information Systems (Data and Application) Architectures

 

Chapter 6 Phase C: Data Architecture

  • The objectives of the Data Architecture part of Phase C are to:
    • Develop the Target Data Architecture that enables the Business Architecture and the Architecture Vision, while addressing the Request for Architecture Work and stakeholder concerns
    • Identify candidate Architecture Roadmap components based upon gaps between the Baseline and Target Data Architectures
  • Data Architecture consists of the following steps:
    • 1. Select reference models, viewpoints, and tools
    • 2. Develop Baseline Data Architecture Description
    • 3. Develop Target Data Architecture Description
    • 4. Perform Gap Analysis
    • 5. Define candidate roadmap components
    • 6. Resolve impacts across the Architecture Landscape
    • 7. Conduct formal stakeholder review
    • 8. Finalize the Data Architecture
    • 9. Create Architecture Definition Document

Chapter 7 Phase C: Application Architecture

  • The objectives of the Application Architecture part of Phase C are to:
    • Develop the Target Application Architecture that enables the Business Architecture and the Architecture Vision, while addressing the Request for Architecture Work and stakeholder concerns
    • Identify candidate Architecture Roadmap components based upon gaps between the Baseline and Target Application Architectures
  • Phase C: Application Architecture consists of the following steps:
    • 1. Select reference models, viewpoints, and tools
    • 2. Develop Baseline Application Architecture Description
    • 3. Develop Target Application Architecture Description
    • 4. Perform Gap Analysis
    • 5. Define candidate roadmap components
    • 6. Resolve impacts across the Architecture Landscape
    • 7. Conduct formal stakeholder review
    • 8. Finalize the Application Architecture
    • 9. Create Architecture Definition Document

Chapter 8 Phase D: Technology Architecture

  • The objectives of Phase D: Technology Architecture are to:
    • Develop the Target Technology Architecture that enables the logical and physical application and data components and the Architecture Vision, addressing the Request for Architecture Work and stakeholder concerns
    • Identify candidate Architecture Roadmap components based upon gaps between the Baseline and Target Technology Architectures
  • Phase D consists of the following steps:
    • 1. Select reference models, viewpoints, and tools
    • 2. Develop Baseline Technology Architecture Description
    • 3. Develop Target Technology Architecture Description
    • 4. Perform Gap Analysis
    • 5. Define candidate roadmap components
    • 6. Resolve impacts across the Architecture Landscape
    • 7. Conduct formal stakeholder review
    • 8. Finalize the Technology Architecture
    • 9. Create Architecture Definition Document
  • Components of the Architecture Definition Document: The topics that should be addressed in the Architecture Definition Document related to Technology Architecture are as follows:
    • Baseline Technology Architecture, if appropriate
    • Target Technology Architecture, including:
      • Technology components and their relationships to information systems
      • Technology platforms and their decomposition, showing the combinations of technology required to realize a particular technology “stack”
      • Environments and locations with a grouping of the required technology into computing environments (e.g., development, production)
      • Expected processing load and distribution of load across technology components
      • Physical (network) communications
      • Hardware and network specifications
    • Views corresponding to the selected viewpoints addressing key stakeholder concerns.

TOGAF Certification Series 5: Building Blocks

Chapter 11 Building Blocks

  • A building block is a package of functionality defined to meet business needs across an organization. A building block has published interfaces to access functionality. A building block may interoperate with other, possibly inter-dependent building blocks.
  • An architecture is a composition of:
    • A set of building blocks depicted in an architectural model
    • A specification of how those building blocks are connected to meet the overall requirements of an information system
  • Architecture Building Blocks (ABBs) are architecture documentation and models from the enterprise’s Architecture Repository classified according to the Architecture Continuum.
  • The characteristics of ABBs are as follows:
    • They define what functionality will be implemented.
    • They capture architecture requirements; e.g., Business, Data, Application, and Technology requirements.
    • They direct and guide the development of Solution Building Blocks
  • The characteristics of ABBs are as follows:
    • They define what functionality will be implemented.
    • They capture architecture requirements; e.g., Business, Data, Application, and Technology requirements.
    • They direct and guide the development of Solution Building Blocks

  • Building blocks are what you use; patterns can tell you how you use them, when, why, and what trade-offs you have to make in doing that. Patterns offer the promise of helping the architect to identify combinations of Architecture and/or Solution Building Blocks (ABBs/SBBs) that have been proven to deliver effective solutions in the past and may provide the basis for effective solutions in the future.

Chapter 12 ADM Deliverables

  • Architecture Building Blocks (ABBs): ABBs are architecture documentation and models from the enterprise’s Architecture Repository.
  • Architecture Contract: Architecture Contracts are the joint agreements between development partners and sponsors on the deliverables, quality, and fitness-for-purpose of an architecture. They are produced in Phase G: Architecture Governance. Successful implementation of these agreements will be delivered through effective Architecture Governance.
  • Architecture Definition Document: The Architecture Definition Document is the deliverable container for the core architectural artifacts created during a project and for important related information. The Architecture Definition Document spans all architecture domains (Business, Data, Application, and Technology) and also examines all relevant states of the architecture (baseline, transition, and target).
  • Architecture Definition Document versus Architecture Requirements Specification The Architecture Definition Document is a companion to the Architecture Requirements Specification, with a complementary objective: The Architecture Definition Document provides a qualitative view of the solution and aims to communicate the intent of the architects. The Architecture Requirements Specification provides a quantitative view of the solution, stating measurable criteria that must be met during the implementation of the architecture.
  • Architecture Requirements Specification: The Architecture Requirements Specification provides a set of quantitative statements that outline what an implementation project must do in order to comply with the architecture. An Architecture Requirements Specification will typically form a major component of an implementation contract or a contract for more detailed Architecture Definition.
  • Architecture Roadmap: The Architecture Roadmap lists individual work packages that will realize the Target Architecture and lays them out on a timeline to show progression from the Baseline Architecture to the Target Architecture. The Architecture Roadmap highlights individual work packages’ business value at each stage. Transition Architectures necessary to effectively realize the Target Architecture are identified as intermediate steps. The Architecture Roadmap is incrementally developed throughout Phases E and F, and informed by the roadmap components developed in Phases B, C, and D.
  • The Architecture Vision is created in Phase A and provides a high-level summary of the changes to the enterprise that will follow from successful deployment of the Target Architecture.
  • Business principles, business goals, and business drivers provide context for architecture work, by describing the needs and ways of working employed by the enterprise. These will have usually been defined elsewhere in the enterprise prior to the architecture activity. Many factors that lie outside the consideration of architecture discipline may have significant implications for the way that architecture is developed.

Chapter 13 TOGAF Reference Models

  • Major characteristics of a Foundation Architecture include the following:
    • It reflects general computing requirements.
    • It reflects general building blocks.
    • It defines technology standards for implementing these building blocks. It provides direction for products and services.
    • It reflects the function of a complete, robust computing environment that can be used as a foundation.
    • It provides open system standards, directions, and recommendations.
    • It reflects directions and strategies.
  • The TRM has two main components:
    • 1. A taxonomy that defines terminology, and provides a coherent description of the components and conceptual structure of an information system
    • 2. A model, with an associated TRM graphic, that provides a visual representation of the taxonomy, as an aid to understanding

  • The Integrated Information Infrastructure Reference Model: The III-RM is a reference model that focuses on the Application Software space, and is a “Common Systems Architecture” in Enterprise Continuum terms. The III-RM is a subset of the TOGAF TRM in terms of its overall scope, but it also expands certain parts of the TRM – in particular, the business applications and infrastructure applications parts – in order to provide help in addressing one of the key challenges facing the enterprise architect today: the need to design an integrated information infrastructure to enable Boundaryless Information Flow.

  • Boundaryless Information Flow 1. A trademark of The Open Group. 2. A shorthand representation of “access to integrated information to support business process improvements” representing a desired state of an enterprise’s infrastructure specific to the business needs of the organization. An infrastructure that provides Boundaryless Information Flow has open standard components that provide services in a customer’s extended enterprise that:  Combine multiple sources of information  Securely deliver the information whenever and wherever it is needed, in the right context for the people or systems using that information

TOGAF Certification Series 4: The ADM Guidelines and Techniques

Chapter 8 ADM Guidelines and Techniques

  • Architecture Principles: are a set of general rules and guidelines for the architecture being developed. They are intended to be enduring and seldom amended and inform and support the way in which an organization sets about fulfilling its mission. Often, they are one element of a structured set of ideas that collectively define and guide the organization, from values through to actions and results.
  • Enterprise principles provide a basis for decision-making throughout an enterprise and dictate how the organization fulfills its mission. Such principles are commonly used as a means of harmonizing decision-making. They are a key element in a successful Architecture Governance strategy. Within the broad domain of enterprise principles, it is common to have subsidiary principles within a business or organizational unit; for example, IT, HR, domestic operations, or overseas operations.
  • Architecture principles are a set of principles that relate to architecture work. They reflect consensus across the enterprise, and embody the spirit of the enterprise architecture. Architecture principles govern the architecture process, affecting the development, maintenance, and use of the enterprise architecture.
  • The TOGAF Template for Defining Architecture Principles:
    • Name
    • Statement
    • Rationale
    • Implications
  • What Makes a Good Architecture Principle?
    • Understandability
    • Robustness
    • Completeness
    • Consistency
    • Stability
  • Business Scenarios
    • What is a Business Scenario? Business scenarios are a technique used to help identify and understand the business requirements that an architecture must address. A business scenario describes:
      • A business process, application, or set of applications
      • The business and technology environment
      • The people and computing components (“actors”) who execute the scenario
      • The desired outcome of proper execution
    • The technique may be used iteratively, at different levels of detail in the hierarchical decomposition of the Business Architecture. The generic business scenario process is as follows:
      • Identify, document, and rank the problem that is driving the project
      • Document, as high-level architecture models, the business and technical environments where the problem situation is occurring
      • Identify and document desired objectives; the results of handling the problems successfully.
      • Identify human actors and their place in the business model, the human participants, and their roles.
      • Identify computer actors and their place in the technology model, the computing elements, and their roles
      • Identify and document roles, responsibilities, and measures of success per actor, the required scripts per actor, and the desired results of handling the situation properly.
      • Check for fitness-for-purpose of inspiring subsequent architecture work and refine only if necessary.

A good business scenario represents a significant business need or problem and enables vendors to understand the value of a solution to the customer. A good business scenario is also “SMART”:

  • Specific, by defining what needs to be done
  • Measurable, through clear metrics for success
  • Actionable, by clearly segmenting the problem and providing the basis for a solution
  • Realistic, in that the problem can be solved within the bounds of physical reality, time, and cost constraints
  • Time-bound, in that there is a clear statement of when the opportunity expires.
  • Gap Analysis: A key step in validating an architecture is to consider what may have been forgotten. The architecture must support all the essential information processing needs of the organization. The most critical source of gaps that should be considered is stakeholder concerns that have not been addressed in prior architectural work.
  • The determination of interoperability occurs throughout the ADM:
    • In Phase A: Architecture Vision, the nature and security considerations of information and service exchanges are found using business scenarios.
    • In Phase B: Business Architecture, information and service exchanges are defined in business terms.
    • In Phase C: Data Architecture, the content of information exchanges is detailed using the corporate data and/or information exchange model.
    • In Phase C: Application Architecture, the ways that applications are to share information and services are specified.
    • In Phase D: Technology Architecture, appropriate technical mechanisms to permit information and service exchanges are specified.
    • In Phase E: Opportunities & Solutions, actual solutions are selected.
    • In Phase F: Migration Planning, interoperability is implemented logically.
  • Business Transformation Readiness Assessment: The recommended activities are:
    • Determine the readiness factors that will impact the organization
    • Present the readiness factors using maturity models
    • Assess the readiness factors, and determine the readiness factor ratings
    • Assess the risks for each readiness factor and identify improvement actions to mitigate the risk
    • Document the findings into the Capability Assessment and later incorporate the actions into the Implementation and Migration Plan in Phases E and F
  • Risk Management: is a technique used to mitigate risk when implementing an architecture project. There are two levels of risk that should be considered:
    • Initial Level of Risk: Risk categorization prior to determining and implementing mitigating actions. Residual Level of Risk: Risk categorization after implementation of mitigating actions.
  • The recommended process for managing risk consists of the following activities:
    • Risk classification
    • Risk identification
    • Initial risk assessment
    • Risk mitigation and residual risk assessment
    • Risk monitoring
  • Capability-Based Planning: Capability-Based Planning is a business planning technique that focuses on business outcomes. It is business-driven and business-led and combines the requisite efforts of all lines of business to achieve the desired capability. It accommodates most, if not all, of the corporate business models and is especially useful in organizations where a latent capability to respond (e.g., an emergency preparedness unit) is required and the same resources are involved in multiple capabilities. Often the need for these capabilities is discovered and refined using business scenarios.

Chapter 9 Architecture Governance

  • Architecture Governance includes the following:
    • Implementing a system of controls over the creation and monitoring of all architectural components and activities, to ensure the effective introduction, implementation, and evolution of architectures within the organization
    • Implementing a system to ensure compliance with internal and external standards and regulatory obligations
    • Establishing processes that support effective management of the above processes within agreed parameters
    • Developing practices that ensure accountability to a clearly identified stakeholder community, both inside and outside the organization
  • What is Governance? Governance is about ensuring that business is conducted properly. It is less about overt control and strict adherence to rules, and more about effective usage of resources to ensure sustainability of an organization’s strategic objectives. The following characteristics, adapted from Corporate Governance (Naidoo, 2002), are used in the TOGAF standard to highlight both the value and necessity for governance as an approach to be adopted within organizations and their dealings with all involved parties:
    • Discipline: All involved parties will have a commitment to adhere to procedures, processes, and authority structures established by the organization.
    • Transparency: All actions implemented, and their decision support will be available for inspection by authorized organization and provider parties.
    • Independence: All processes, decision-making, and mechanisms used will be established to minimize or avoid potential conflicts of interest.
    • Accountability: Identifiable groups within the organization – e.g., governance boards who take actions or make decisions – are authorized and accountable for their actions.
    • Responsibility: Each contracted party is required to act responsibly to the organization and its stakeholders.
    • Fairness: All decisions taken, processes used, and their implementation will not be allowed to create unfair advantage to any one party.
  • Architecture Governance covers the management and control of all aspects of the development and evolution of architectures. It needs to be supported by an Architecture Governance Framework which assists in identifying effective processes so that the business responsibilities associated with Architecture Governance can be elucidated, communicated, and managed effectively.

  • Key Architecture Governance Processes The following are the key processes:
    • 1. Policy Management and Take-On
    • 2. Compliance
    • 3. Dispensation
    • 4. Monitoring and Reporting
    • 5. Business Control
    • 6. Environment Management

  • Architecture Governance is beneficial because it:
    • Links IT processes, resources, and information to organizational strategies and objectives
    • Integrates and institutionalizes IT best practices
    • Aligns with industry frameworks such as COBIT (planning and organizing, acquiring and implementing, delivering and supporting, and monitoring IT performance)
    • Enables the organization to take full advantage of its information, infrastructure, and hardware/software assets
    • Protects the underlying digital assets of the organization
    • Supports regulatory and best practice requirements such as auditability, security, responsibility, and accountability
  • What are the Key Success Factors when establishing Architecture Governance? It is important to consider the following to ensure a successful approach to Architecture Governance, and effective management of the Architecture Contract:
    • Establishment and operation of best practices for submission, adoption, re-use, reporting, and retirement of architecture policies, procedures, roles, skills, organizational structures, and support services
    • Establishment of correct organizational responsibilities and structures to support Architecture Governance processes and reporting requirements
    • Integration of tools and processes to facilitate take-up of processes (both procedural and cultural)
    • Management of criteria for control of Architecture Governance processes, dispensations, compliance assessments, Service Level Agreements (SLAs), and Operational Level Agreements (OLAs)
    • Meeting internal and external requirements for effectiveness, efficiency, confidentiality, integrity, availability, compliance, and reliability of Architecture Governance-related information, services, and processes
  • The Architecture Board is typically made responsible, and accountable, for achieving some or all the following goals:
    • Providing the basis for all decision-making about changes to the architectures
    • Consistency between sub-architectures
    • Establishing targets for re-use of components
    • Flexibility of enterprise architecture; to meet business needs and utilize new technologies
    • Enforcement of Architecture Compliance
    • Improving the maturity level of architecture discipline within the organization
    • Ensuring that the discipline of architecture-based development is adopted
    • Supporting a visible escalation capability for out-of-bounds decisions
  • The Meaning of Architecture Compliance:

Chapter 10 Views, Viewpoints, and Stakeholders

  • A system is a collection of components organized to accomplish a specific function or set of functions. “The term system encompasses individual applications, systems in the traditional sense, subsystems, systems of systems, product lines, product families, whole enterprises, and other aggregations of interest
  • Stakeholders are people who have key roles in, or concerns about, the system; for example, users, developers, etc. Stakeholders can be individuals, teams, organizations, etc.
  • Concerns are key interests that are crucially important to stakeholders and determine the acceptability of the system.
  • A view is a representation of a system from the perspective of a related set of concerns. A view is what you see (or what a stakeholder sees). An architect creates architecture models. A view consists of parts of these, chosen to show stakeholders that their concerns are being met.
  • A viewpoint defines the perspective from which a view is taken. It defines how to construct and use a view, the information needed, the modeling techniques for expressing and analyzing it, and a rationale for these choices (e.g., by describing the purpose and intended audience of the view). The relationship between viewpoint and view is analogous to that of a template and an instance of the completed template. In constructing an enterprise architecture, an architect first selects the viewpoints (templates), then constructs a set of corresponding views (instances).
  • The architect has a responsibility for ensuring:
    • The completeness of the architecture: — Does it address all the concerns of its stakeholders?
    • The integrity of the architecture: — Can the views be connected to each other? — Can the conflicting concerns be reconciled? — What trade-offs have been made (e.g., between security and performance)?
  • Recommended Steps: The following are the recommended steps to create the required views for a architecture:
    • 1. Refer to any existing libraries of viewpoints (note that TOGAF 9 includes a set of architecture viewpoints).
    • 2. Select key stakeholders.
    • 3. Analyze their concerns and document them.
    • 4. Select appropriate viewpoints (based on the stakeholders and their concerns).
    • 5. Generate views of the system using the selected viewpoints as templates.

TOGAF Certification Series 3: The Architecture Development Method

Chapter 5: Introduction to the Architecture Development Method

  • The Architecture Development Cycle

    • Preliminary Phase: Prepares the organization for successful TOGAF architecture projects. Undertake the preparation and initiation activities required to create an Architecture Capability, including the customization of the TOGAF framework, selection of tools, and the definition of Architecture Principles.
    • Requirements Management: Every stage of a TOGAF project is based on and validates business requirements. Requirements are identified, stored, and fed into and out of the relevant ADM phases, which dispose of, address, and prioritize requirements.
    • Phase A: Architecture Vision: Sets the scope, constraints, and expectations for a TOGAF project. Create the Architecture Vision, Identify stakeholders, Validate the business context and create the Statement of Architecture Work, and Obtain approvals.
    • Phase B: Business Architecture Phase C: Information Systems Architectures (Application & Data) Phase D: Technology Architecture Develop architectures in four domains:
      • 1. Business
      • 2. Information Systems – Application
      • 3. Information Systems – Data
      • 4. Technology

      In each case, develop the Baseline and Target Architecture and analyze gaps.

    • Phase E: Opportunities & Solutions Perform initial implementation planning and the identification of delivery vehicles for the building blocks identified in the previous phases. Determine whether an incremental approach is required, and if so identify Transition Architectures.
    • Phase F: Migration Planning Develop Detailed Implementation and Migration Plan that addresses how to move from the Baseline to the Target Architecture.
    • Phase G: Implementation Governance Provide architectural oversight for the implementation. Prepare and issue Architecture Contracts. Ensure that the implementation project conforms to the architecture.
    • Phase H: Architecture Change Management: Provide continual monitoring and a change management process to ensure that the architecture responds to the needs of the enterprise and maximizes the value of the architecture to the business.

Chapter 6: The Enterprise Continuum and Tools

  • The Architecture Repository:
    • The Architecture Metamodel describes the organizationally tailored application of an architecture framework, including a method for architecture development and a metamodel for architecture content.
    • The Architecture Capability defines the parameters, structures, and processes that support governance of the Architecture Repository.
    • The Architecture Landscape presents an architectural representation of assets in use, or planned, by the enterprise at particular points in time.
    • The Standards Information Base captures the standards with which new architectures must comply, which may include industry standards, selected products and services from suppliers, or shared services already deployed within the organization. The Open Group provides an example of a Standards Information Base on its web site.
    • The Reference Library provides guidelines, templates, patterns, and other forms of reference material that can be leveraged in order to accelerate the creation of new architectures for the enterprise.
    • The Governance Log provides a record of governance activity across the enterprise.

Chapter 7: The ADM Phases

  • Preliminary Phase: includes the preparation and initiation activities to create an Architecture Capability. Key activities are as follows:
    • Understand the business environment
    • Ensure high-level management commitment
    • Obtain agreement on scope
    • Establish architecture principles
    • Establish governance structure
    • Customization of the TOGAF framework
  • Business Capability Management (Business Direction and Planning) which determine what business capabilities are required.
  • Portfolio/Project Management Methods which determine how a company manages its change initiatives.
  • Operations Management Methods which describe how a company runs its day-to-day operations, including IT.
  • Solution Development Methods which formalize the way that business systems are delivered

  • Phase A: Architecture Vision: Phase A is about project establishment and initiates an iteration of the Architecture Development Cycle, setting the scope, constraints, and expectations for the iteration. Objectives:
    • Develop a high-level aspirational vision of the capabilities and business value to be delivered because of the proposed enterprise architecture.
    • Obtain approval for a Statement of Architecture Work that defines a program of works to develop and deploy the architecture outlined in the Architecture Vision.
  • Phase B: Business Architecture Phase B is about development of a Business Architecture to support an agreed Architecture Vision. This describes the fundamental organization of a business embodied in:
    • Its business process and people
    • Their relationships to each other and the people
    • The principles governing its design and evolution
    • and shows how an organization meets its business goals.
  • Objectives are:
    • Develop the Target Business Architecture describing how the enterprise needs to operate to achieve the business goals, responds to the strategic drivers set out in the Architecture Vision, and addresses the Request for Architecture Work and stakeholder concerns
    • Identify candidate Architecture Roadmap components based upon gaps between the Baseline and Target Business Architectures
  • Phase C: Information Systems Architectures: Phase C is about documenting the Information Systems Architectures for an architecture project, including the development of Data and Application Architectures. This describes the major types of information and the application systems that process the information, and their relationships to each other and the environment. There are two steps in this phase, which may be developed either sequentially or concurrently:
    • Data Architecture
    • Application Architecture
  • Objectives
    • Develop the Target Information Systems (Data and Application) Architecture, describing how the enterprise’s Information Systems Architecture will enable the Business Architecture and the Architecture Vision, in a way that addresses the Request for Architecture Work and stakeholder concerns.
    • Identify candidate Architecture Roadmap components based upon gaps between the Baseline and Target Information Systems (Data and Application) Architectures
  • Key Considerations for the Data Architecture:
    • Data Management
      • Defining application components which will serve as the system of record or reference for enterprise master data
      • Defining enterprise-wide standards that all application components, including software packages, need to adopt
      • Understanding how data entities are utilized by business functions, processes, and services
      • Understanding how and where enterprise data entities are created, stored, transported, and reported
      • Understanding the level and complexity of data transformations required to support the information exchange needs between applications
      • Defining the requirement for software in supporting data integration with the enterprise’s customers and suppliers (e.g., use of ETL tools during the data migration, data profiling tools to evaluate data quality, etc.)
    • Data Migration
    • Data Governance
  • Phase D: Technology Architecture is about documenting the Technology Architecture for an architecture project, in the form of the fundamental organization of the IT systems:
    • Embodied in the hardware, software, and communications technology
    • Their relationships to each other and the environment
    • The principles governing its design and evolution
  • Objectives
    • Develop the Target Technology Architecture that enables the logical and physical application and data components and the Architecture Vision, addressing the Request for Architecture Work and stakeholder concerns
    • Identify candidate Architecture Roadmap components based upon gaps between the Baseline and Target Technology Architectures
  • Phase E: Opportunities and Solutions: is the first phase which is directly concerned with implementation. It describes the process of identifying major implementation projects and grouping them into work packages that deliver the Target Architecture identified in previous phases. Key activities are as follows:
    • Perform initial implementation planning
    • Identify the major implementation projects
    • Group changes into work packages
    • Decide on approach: — Make versus buy versus re-use — Outsource — COTS — Open Source
    • Assess priorities
    • Identify dependencies
  • Objectives
    • Generate the initial complete version of the Architecture Roadmap, based upon the gap analysis and candidate Architecture Roadmap components from Phases B, C, and D
    • Determine whether an incremental approach is required, and if so identify Transition Architectures that will deliver continuous business value.
  • Phase F: Migration Planning: addresses detailed migration planning; that is, how to move from the Baseline to the Target Architectures. Key activities include:
    • For work packages and projects identified, perform a cost/benefit analysis and a risk assessment
    • Finalize a detailed Implementation and Migration Plan
  • Objectives
    • Finalize the Architecture Roadmap and the supporting Implementation and Migration Plan
    • Ensure that the Implementation and Migration Plan is coordinated with the enterprise’s approach to managing and implementing change in the enterprise’s overall change portfolio
    • Ensure that the business value and cost of work packages and Transition Architectures is understood by key stakeholders
  • Phase G: Implementation Governance: defines how the architecture constrains the implementation projects, monitors it while building it, and produces a signed Architecture Contract. Key activities include:
    • Provide architectural oversight for the implementation
    • Define architecture constraints on implementation projects
    • Govern and manage an Architecture Contract
    • Monitor implementation work for conformance
  • Objectives
    • Ensure conformance with the Target Architecture by implementation projects
    • Perform appropriate Architecture Governance functions for the solution and any implementation-driven architecture Change Requests
  • Phase H: Architecture Change Management: ensures that changes to the architecture are managed in a controlled manner. Key activities include:
    • Provide continual monitoring and a change management process
    • Ensure that changes to the architecture are managed in a cohesive and architected way
    • Provide flexibility to evolve rapidly in response to changes in the technology or business environment
    • Monitor the business and capacity management
  • Objectives
    • Ensure that the architecture lifecycle is maintained
    • Ensure that the Architecture Governance Framework is executed
    • Ensure that the enterprise’s Architecture Capability meets current requirement
  • Requirements Management: The process of managing architecture requirements applies to all phases of the ADM cycle. The Requirements Management process is a dynamic process, which addresses the identification of requirements for the enterprise, stores them, and then feeds them in and out of the relevant ADM phases. This process is central to driving the ADM process.
  • Objectives
    • Ensure that the Requirements Management process is sustained and operates for all relevant ADM phases
    • Manage architecture requirements identified during any execution of the ADM cycle or a phase
    • Ensure that the relevant architecture requirements are available for use by each phase as the phase is executed.

TOGAF Certification Series 2: Foundations Core Concepts

Chapter 3: Core Concepts

  • What are the ADM phase names and the purpose of each phase?


  • The Preliminary Phase describes the preparation and initiation activities required to create an Architecture Capability, including the customization of the TOGAF framework, and the definition of Architecture Principles.
  • Phase A: Architecture Vision describes the initial phase of an Architecture Development Cycle. It includes information about defining the scope, identifying the stakeholders, creating the Architecture Vision, and obtaining approvals.
  • Phase B: Business Architecture describes the development of a Business Architecture to support an agreed Architecture Vision.
  • Phase C: Information Systems Architectures describes the development of Information Systems Architectures for an architecture project, including the development of Data and Application Architectures.
  • Phase D: Technology Architecture describes the development of the Technology Architecture for an architecture project.
  • Phase E: Opportunities and Solutions describes the process of identifying major implementation projects and grouping them into work packages that deliver the Target Architecture defined in the previous phases.
  • Phase F: Migration Planning describes the development of a detailed Implementation and Migration Plan that addresses how to move from the Baseline to the Target Architecture.
  • Phase G: Implementation Governance provides an architectural oversight of the implementation.
  • Phase H: Architecture Change Management establishes procedures for managing change to the new architecture.
  • Requirements Management examines the process of managing architecture requirements throughout the ADM.
  • What are deliverables, artifacts, and building blocks?


  • What is the Enterprise Continuum?

The Enterprise Continuum is a view of the Architecture Repository that provides methods for classifying architecture and solution artifacts as they evolve from generic Foundation Architectures to Organization-Specific Architectures. The Enterprise Continuum comprises two complementary concepts: the Architecture Continuum and the Solutions Continuum.

The Enterprise Continuum and the Architecture Repository The Enterprise Continuum provides a view of the Architecture Repository that shows the evolution of these related architectures from generic to specific, from abstract to concrete, and from logical to physical. [Source: TOGAF 9 Part V: Enterprise Continuum and Tools]

  • What is the Architecture Repository?

Architecture Repository is used to store different classes of architectural output at different levels of abstraction

The major components within an Architecture Repository are as follows:

  • The Architecture Metamodel describes the organizationally tailored application of an architecture framework, including a metamodel for architecture content.
  • The Architecture Capability defines the parameters, structures, and processes that support governance of the Architecture Repository.
  • The Architecture Landscape shows an architectural view of the building blocks that are in use within the organization today (e.g., a list of the live applications). The landscape is likely to exist at multiple levels of abstraction to suit different architecture objectives
  • The Standards Information Base (SIB) captures the standards with which new architectures must comply, which may include industry standards, selected products and services from suppliers, or shared services already deployed within the organization.
  • The Reference Library provides guidelines, templates, patterns, and other forms of reference material that can be leveraged to accelerate the creation of new architectures for the enterprise.
  • The Governance Log provides a record of governance activity across the enterprise. abstraction to suit different architecture objectives
  • How to establish and operate an enterprise architecture capability?



    The benefits of Architecture Governance include:

  • Increased transparency of accountability, and informed delegation of authority
  • Controlled risk management
  • Protection of the existing asset base through maximizing re-use of existing architectural components
  • Proactive control, monitoring, and management mechanisms
  • Process, concept, and component re-use across all organizational business units
  • Value creation through monitoring, measuring, evaluation, and feedback
  • Increased visibility supporting internal processes and external parties’ requirements; in particular, increased visibility of decision-making at lower levels ensures oversight at an appropriate level within the enterprise of decisions that may have far-reaching strategic consequences for the organization
  • Greater shareholder value; in particular, enterprise architecture increasingly represents the core intellectual property of the enterprise – studies have demonstrated a correlation between increased shareholder value and well-governed enterprises
  • Integrates with existing processes and methodologies and complements functionality by adding control capabilities
  • How to use the TOGAF framework with other frameworks?

Why is the TOGAF standard becoming so popular in the industry? One key reason is that architects can use the TOGAF ADM in conjunction with any of the popular frameworks. The TOGAF ADM is framework-agnostic and helps IT architects fill in the framework they might already have in use.

Chapter 4: Key Terminology

  • Architecture: Architecture has two meanings depending upon its contextual usage:
    • A formal description of a system, or a detailed plan of the system at component level to guide its implementation
    • The structure of components, their inter-relationships, and the principles and guidelines governing their design and evolution over time.
  • Architecture Principles: A qualitative statement of intent that should be met by the architecture. Has at least a supporting rationale and a measure of importance.
  • Architecture Vision: A succinct description of the Target Architecture that describes its business value and the changes to the enterprise that will result from its successful deployment. It serves as an aspirational vision and a boundary for detailed architecture development.
  • Baseline: A specification that has been formally reviewed and agreed upon, that thereafter serves as the basis for further development or change and that can be changed only through formal change control procedures or a type of procedure such as configuration management.

TOGAF Certification Series 1: Foundations Introduction

Chapter 1 Introduction:

  • Why is TOGAF certification important? The existence of a certification program for the TOGAF standard provides a strong incentive for organizations to standardize on the TOGAF standard as the open method for enterprise architecture, and so avoid lock-in to proprietary methods. It is an important step in making enterprise architecture a well-recognized discipline, and in introducing rigor into the procurement of tools and services for enterprise architecture.
  • The purpose of certification to TOGAF 9 Level 1, known as TOGAF 9 Foundation, is to provide validation that the candidate has gained an acceptable level of knowledge of the terminology, structure, and basic concepts of TOGAF 9, and understands the core principles of enterprise architecture and the TOGAF standard
  • Individuals certified at this level will have demonstrated their understanding of:
    • The basic concepts of enterprise architecture and the TOGAF standard
    • The core concepts of TOGAF 9
    • The key terminology of TOGAF 9 
    • The ADM cycle and the objectives of each phase, and how to adapt and scope the ADM
    • The concept of the Enterprise Continuum; its purpose, and its constituent parts
    • How each of the ADM phases contributes to the success of enterprise architecture
    • The ADM guidelines and techniques
    • How Architecture Governance contributes to the Architecture Development Cycle
    • The concepts of views and viewpoints and their role in communicating with stakeholders
    • The concept of building blocks
    • The key deliverables of the ADM cycle
    • The TOGAF reference models
    • The TOGAF certification program
  • What is the relationship between TOGAF 9 Foundation and TOGAF 9 Certified? The learning outcomes for TOGAF 9 Foundation are a subset of those for TOGAF 9 Certified. Candidates are able to choose whether they wish to become certified in a stepwise manner by starting with TOGAF 9 Foundation and then at a later date TOGAF 9 Certified, or alternately to go direct to TOGAF 9 Certified by taking the combined examination

Chapter 2 Basic Concepts:

  • What is the TOGAF Standard? The TOGAF standard is an architecture framework. The TOGAF standard is a tool for assisting in the acceptance, production, use, and maintenance of enterprise architectures. It is based on an iterative process model supported by best practices and a re-usable set of existing architectural assets.
  • Structure of the TOGAF Document:
    • Part I: Introduction This part provides a high-level introduction to the key concepts of enterprise architecture and, in particular, to the TOGAF approach. It contains the definitions of terms used throughout the TOGAF standard and release notes detailing the changes between this version and the previous version of the TOGAF standard.
    • Part II: Architecture Development Method (ADM) This part is the core of the TOGAF standard. It describes the TOGAF Architecture Development Method (ADM) – a step-by-step approach to developing an enterprise architecture.
    • Part III: ADM Guidelines and Techniques This part contains a collection of guidelines and techniques available for use in applying the ADM.
    • Part IV: Architecture Content Framework This part describes the TOGAF content framework, including a structured metamodel for architectural artifacts, the use of re-usable Architecture Building Blocks (ABBs), and an overview of typical architecture deliverables.
    • Part V: Enterprise Continuum and Tools: This part discusses appropriate taxonomies and tools to categorize and store the outputs of architecture activity within an enterprise.
    • Part VI: TOGAF Reference Models: This part provides two architectural reference models, namely the TOGAF Technical Reference Model (TRM), and the Integrated Information Infrastructure Reference Model (III-RM).
    • Part VII: Architecture Capability Framework: This part discusses the organization, processes, skills, roles, and responsibilities required to establish and operate an architecture practice within an enterprise.
  • What is an Enterprise? An “enterprise” is any collection of organizations that has a common set of goals. For example, an enterprise could be a government agency, a whole corporation, a division of a corporation, a single department, or a chain of geographically distant organizations linked together by common ownership. The term “enterprise” in the context of “enterprise architecture” can be used to denote both an entire enterprise, encompassing all of its information systems, and a specific domain within the enterprise. An extended enterprise frequently includes partners, suppliers, and customers. If the goal is to integrate an extended enterprise, then the enterprise comprises the partners, suppliers, and customers, as well as internal business units. For example, an organization with an online store that uses an external fulfillment house for dispatching orders would extend its definition of the enterprise in that system to include the fulfillment house.
  • What is Architecture in the Context of the TOGAF Standard? Architecture has two meanings depending upon the context:
    • 1. A formal description of a system, or a detailed plan of the system at a component level to guide its implementation \
    • 2. The structure of components, their inter-relationships, and the principles and guidelines governing their design and evolution over time
  • Enterprise architecture is:
    • 1. The organizing logic for business processes and IT infrastructure reflecting the integration and standardization requirements of the firm’s operating model.
    • 2. A conceptual blueprint that defines the structure and operation of an organization. The intent of an enterprise architecture is to determine how an organization can most effectively achieve its current and future objectives.
  • Why do I Need Enterprise Architecture? The purpose of enterprise architecture is to optimize across the enterprise the often fragmented legacy of processes (both manual and automated) into an integrated environment that is responsive to change and supportive of the delivery of the business strategy. Effective management and exploitation of information through IT is a key factor to business success, and an indispensable means to achieving competitive advantage. An enterprise architecture addresses this need, by providing a strategic context for the evolution of the IT system in response to the constantly changing needs of the business environment. Ultimately, the benefits of enterprise architecture derive from the better planning, earlier visibility, and more informed designs that result when it is introduced.
  • What is an Architecture Framework? An architecture framework is a foundational structure, or set of structures, that can be used for developing a broad range of different architectures. It should describe a method for designing a target state of the enterprise in terms of a set of building blocks, and for showing how the building blocks fit together. It should contain a set of tools and provide a common vocabulary. It should also include a list of recommended standards and compliant products that can be used to implement the building blocks. Using an architecture framework will speed up and simplify architecture development, ensure more complete coverage of the designed solution, and make certain that the architecture selected allows for future growth in response to the needs of the business.
  • Why is the TOGAF Standard Suitable as a Framework for Enterprise Architecture? Using the TOGAF standard results in enterprise architecture that is consistent, reflects the needs of stakeholders, employs best practice, and gives due consideration both to current requirements and to the perceived future needs of the business.
  • What are the Different Architecture Domains that the TOGAF Standard deals with?
    • Business Architecture: The business strategy, governance, organization, and key business processes.
    • Data Architecture: The structure of an organization’s logical and physical data assets and data management resources.
    • Application Architecture: A blueprint for the individual application systems to be deployed, their interactions, and their relationships to the core business processes of the organization.
    • Technology Architecture: The software and hardware capabilities that are required to support the deployment of business, data, and application services. This includes IT infrastructure, middleware, networks, communications, processing, and standards.
  • Definition of “Capability”: An ability that an organization, person, or system possesses. Capabilities are typically expressed in general and high-level terms and typically require a combination of organization, people, processes, and technology to achieve. For example, marketing, customer contact, or outbound telemarketing.
    • An enterprise architecture capability (or architecture capability) in the context of the TOGAF standard, is the ability for an organization to effectively undertake the activities of an enterprise architecture practice.
  • What does the TOGAF Standard Contain?
  • TOGAF Reference Models
    • TOGAF Foundation Architecture Technical Reference Model: The TOGAF Technical Reference Model is an architecture of generic services and functions that provides a foundation on which specific architectures and Architecture Building Blocks (ABBs) can be built.
    • Integrated Information Infrastructure Reference Model (III-RM) : The Integrated Information Infrastructure Reference Model (III-RM) is based on the TOGAF Foundation Architecture, and is specifically aimed at helping the design of architectures that enable and support the vision of Boundaryless Information Flow.