Here are the combined Skills for Exams 70-547/70-548/70-549 (and 70-551-Section 3, 70-552-Section 3, and 70-554-Section 2):

1. Envisioning and Designing an Application   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.1. Evaluate the technical feasibility of an application design concept.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.1.1. Evaluate the proof of concept.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.1.2. Recommend the best technologies for the features and goals of the application.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554); 71-549 (and 70-554) adds “Considerations include Message Queuing, Web Services, .NET Framework remoting, and so on.”]

1.1.3. Weigh implementation considerations.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.1.4. Investigate existing solutions for similar business problems.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.2 Create a proof-of-concept prototype.  [Exam 71-547 and 71-548 only (and 70-552)]

1.2.1 Evaluate the risks associated with ASP.NET 2.0 technology or implementation.  [Exam 71-547 and 71-548 only (and 70-552); 71-548 (and 70-552) reads “with the proposed technology”]

1.2.2 Validate that the proposed technology can be used in the application.  [Exam 71-547 and 71-548 only (and 70-552)]

1.2.3. Demonstrate to stakeholders that the proposed solution will address their needs.  [Exam 71-547 and 71-548 only (and 70-552)]

1.3. Evaluate the technical specifications for an application to ensure that the business requirements are met.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.3.1. Translate the functional specification into developer terminology, such as pseudo code and UML diagrams.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.3.2. Suggest component type and layer.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.4. Evaluate the design of a database.  [Exam 71-547, 71-548, and 71-549 (and 70-551 and 70-554)]

1.4.1. Recommend a database schema.   [Exam 71-547, 71-548, and 71-549 (and 70-551 and 70-554)]

1.4.2. Identify the stored procedures that are required for an application.  [Exam 71-547, 71-548, and 71-549 (and 70-551 and 70-554)]

1.5. Evaluate the logical design of an application.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.5.1. Evaluate the logical design for performance.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.5.2. Evaluate the logical design for maintainability.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.5.3. Evaluate the logical design for extensibility.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.5.4. Evaluate the logical design for scalability.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.5.5. Evaluate the logical design for availability.   [Exam 71-547 and 71-549 only (and 70-551 and 70-554)]

1.5.6. Evaluate the logical design for security.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.5.7. Evaluate the logical design against use cases.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.5.8. Evaluate the logical design for recoverability.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.5.9. Evaluate the logical design for data integrity.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.6. Evaluate the physical design of an application. Considerations include the design of the project structure, the number of files, the number of assemblies, and the location of these resources on the server.                           [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.6.1. Evaluate the physical design for performance.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.6.2. Evaluate the physical design for maintainability.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.6.3. Evaluate how the physical location of files affects the extensibility of the application.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.6.4. Evaluate the physical design for scalability.     [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.6.5. Evaluate the physical design for availability.   [Exam 71-547 and 71-549 only (and 70-551 and 70-554)]

1.6.6. Evaluate the physical design for security.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.6.7. Evaluate the physical design for recoverability.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

1.6.8. Evaluate the physical design for data integrity.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

2. Designing and Developing a User Interface   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.1. Choose an appropriate layout for the visual interface.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.1.1. Decide the content flow across pages.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552); 71-548 (and 70-552) reads “flow within the application.”]

2.1.2. Evaluate user navigation needs.    [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.1.3. Identify the goal of the page.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552); 71-548 (and 70-552) reads “goal of the UI.”]

2.1.4. Ensure the congruency and consistency of the user experience throughout the application.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.1.5. Choose techniques to control the layout.   [Exam 71-548 only (and 70-552)]

2.2. Evaluate a strategy for implementing a common layout throughout the UI.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.2.1. Suggest when to use style sheets, master pages, Web parts, custom controls, scripting, and user controls.   [Exam 71-547 only (and 70-551)]

2.2.2. Suggest an applicable UI standard based on the intended client environment. Considerations include chosen operating systems, technologies, and browser types.   [Exam 71-547 only (and 70-551)]

2.2.3. Suggest an applicable UI standard based on the application specification. Considerations include MDI, SDI, control grouping, and so on.   [Exam 71-548 only (and 70-552)]

2.3. Choose an appropriate control based on design specifications.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.3.1. Evaluate the type of data that must be captured or displayed.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.3.2. Evaluate available controls. Considerations include standard .NET Framework controls and custom, internally developed, and third-party controls. [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.3.3. Evaluate how available controls are implemented in previous and ongoing projects or applications.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552); 71-548 (and 70-551 and 70-552) reads “Evaluate the manner in which available controls …”]

2.3.4. Evaluate the user demographic. Considerations include localization concerns.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552); 71-548 (and 70-552) just reads “Evaluate the user demographic.”]

2.3.5. Evaluate the user environment. Considerations include screen size and browser type and version.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552); 71-548 (and 70-552) just reads “Evaluate the user environment.”]

2.4. Choose an appropriate data validation method at the UI layer.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.4.1. Choose a validation method based on the data type provided.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.4.2. Decide how to report the feedback. Considerations include callbacks, exceptions, and writing to an event log.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.4.3. Identify the source of invalid data.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.4.4. Identify the cause of an invalid entry.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.4.5. Evaluate whether invalid data can be prevented.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.4.6. Evaluate whether an exception must be thrown.    [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.4.7. Evaluate whether an exception must be logged.    [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.4.8. Evaluate whether visual feedback, such as a message box or color, is required.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.5. Choose appropriate user assistance and application status feedback techniques.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.5.1. Design a user assistance mechanism.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.5.2. Choose an appropriate application status feedback technique based on available control types.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.5.3. Choose an appropriate application status feedback technique to support accessibility.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.5.4. Design an application status feedback mechanism.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

2.6. Choose an appropriate mechanism to deliver multimedia data from an application.   [Exam 71-547 and 71-548 only]

2.6.1. Evaluate available multimedia delivery mechanisms. Considerations include bandwidth problems, file formats, frames per second, and streaming types.  [Exam 71-547 and 71-548 only]

2.6.2. Design a multimedia delivery mechanism.   [Exam 71-547 and 71-548 only]

3. Designing and Developing a Component    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.1. Establish the required characteristics of a component. [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.1.1. Decide when to create a single component or multiple components.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.1.2. Decide which tier of the application a component should be located.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.1.3. Decide which type of object to build.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.2. Create the high-level design of a component. [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.2.1. Establish the life cycle of a component.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.2.2. Decide whether to use established design patterns for the component.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.2.3. Decide whether to create a prototype for the component. [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.2.4. Document the design of a component by using pseudo code, class diagrams, sequence diagrams, activity diagrams, and state diagrams.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.2.5. Evaluate tradeoff decisions. Considerations include security vs. performance, performance vs. maintainability, and so on.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.3. Develop the public API of a component. [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.3.1. Decide the types of clients that can consume a component.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.3.2. Establish the required component interfaces.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.3.3. Decide whether to require constructor input.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.4. Develop the features of a component. [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.4.1. Decide whether existing functionality can be implemented or inherited.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.4.2. Decide how to handle unmanaged and managed resources.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.4.3. Decide which extensibility features are required.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.4.4. Decide whether a component must be stateful or stateless.  [Exam 71-547 and 71-549 only (and 70-551 and 70-554)]

3.4.5. Decide whether a component must be multithreaded.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.4.6. Decide which functions to implement in the base class, abstract class, or sealed class.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.5. Develop an exception handling mechanism. [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

3.5.1. Decide when it is appropriate to raise an exception.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

3.5.2. Decide how a component will handle exceptions. Considerations include catching and throwing a new exception; catching, wrapping, and throwing the wrapped exception; catching and terminating, and so on.          [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

3.6. Develop a component feedback mechanism. [Exam 71-549 only]

3.6.1. Develop a component status feedback technique.  [Exam 71-549 only]

3.6.2. Develop an exception handling mechanism.  [Exam 71-549 only]

3.7. Develop the data access and data handling features of a component.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.7.1. Analyze data relationships.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.7.2. Analyze the data handling requirements of a component.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

3.8. Develop a component to include profiling requirements.  [Exam 71-547, 71-548, and 71-549 (and 70-552 and 70-554)]

3.8.1. Identify potential issues, such as resource leaks and performance gaps, by profiling a component.  [Exam 71-547, 71-548, and 71-549 (and 70-552 and 70-554)]

3.8.2. Decide when to stop profiling on a component.  [Exam 71-547, 71-548, and 71-549 (and 70-552 and 70-554)]

3.8.3. Decide whether to redesign a component after analyzing the profiling results.  [Exam 71-547, 71-548, and 71-549 (and 70-552 and 70-554)]

3.9. Choose an appropriate mechanism to deliver multimedia data across distributed applications by using Web services and Message Queuing. [Exam 71-549 only (and 70-554)]

3.9.1. Evaluate available multimedia delivery mechanisms. Considerations include bandwidth problems, file formats, and sending large attachments.  [Exam 71-549 only (and 70-554)]

3.9.2. Design a multimedia delivery mechanism.  [Exam 71-549 only (and 70-554)]

4. Designing and Developing an Application Framework   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.1. Consume a reusable software component.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.1.1. Identify a reusable software component from available components to meet the requirements.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.1.2. Identify whether the reusable software component needs to be extended.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.1.3. Identify whether the reusable software component needs to be wrapped.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.1.4. Identify whether any existing functionality needs to be hidden.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.1.5. Test the identified component that is based on the requirements.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.2. Choose an appropriate exception handling mechanism.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

4.2.1. Evaluate the current exception handling mechanism.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

4.2.2. Design a new exception handling technique.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

4.3. Choose an appropriate implementation approach for the application design logic.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.3.1. Choose an appropriate data storage mechanism.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.3.2. Choose an appropriate data flow structure.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.3.3. Choose an appropriate decision flow structure. [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.3.4. Choose an appropriate state management technique.   [Exam 71-549 only (and 70-554)]

4.3.5. Choose an appropriate security implementation  [Exam 71-549 only (and 70-554)]

4.4. Choose an appropriate event logging method for the application.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.4.1. Decide whether to log data. Considerations include policies, security, requirements, and debugging.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.4.2. Choose a storage mechanism for logged events. For example, database, flat file, event log, or XML file.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.4.3. Choose a systemwide event logging method. For example, centralized logging, distributed logging, and so on.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.4.4. Decide logging levels based on severity and priority.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

4.5. Monitor specific characteristics or aspects of an application.  [Exam 71-547, 71-548, and 71-549 (and 70-554)]

4.5.1. Decide whether to monitor data. Considerations include administration, auditing, and application support.  [Exam 71-547, 71-548, and 71-549 (and 70-554)]

4.5.2. Decide which characteristics to monitor. For example, application performance, memory consumption, security auditing, usability metrics, and possible bugs.  [Exam 71-547, 71-548, and 71-549 (and 70-554)]

4.5.3. Choose event monitoring mechanisms, such as System Monitor and logs.  [Exam 71-547, 71-548, and 71-549 (and 70-554)]

4.5.4. Decide monitoring levels based on requirements.   [Exam 71-547, 71-548, and 71-549 (and 70-554)]

4.5.5. Choose a systemwide monitoring method from the available monitoring mechanisms.  [Exam 71-547, 71-548, and 71-549 (and 70-554)]

4.6. Evaluate the application configuration architecture.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

4.6.1. Decide which configuration attributes to store.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

4.6.2. Choose the physical storage location for the configuration attributes.  [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

4.6.3. Decide in which format to store the configuration attributes.   [Exam 71-547 and 71-548 only (and 70-551)]

4.6.4. Choose when to use ASP.NET Administrative tools.   [Exam 71-547 only (and 70-551)]

5. Testing and Stabilizing an Application    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.1. Perform a code review.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.2. Evaluate the testing strategy.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.2.1. Create the unit testing strategy.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.2.2. Evaluate the integration testing strategy.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.2.3. Evaluate the stress testing strategy.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.2.4. Evaluate the performance testing strategy.     [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.2.5. Evaluate the test environment specification.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.3. Design a unit test.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.3.1. Describe the testing scenarios.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.3.2. Decide coverage requirements.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.3.3. Evaluate when to use boundary condition testing.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.3.4. Decide the type of assertion tests to conduct.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.4. Perform integration testing.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.4.1. Determine if the component works as intended in the target environment.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.4.2. Identify component interactions and dependencies.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.4.3. Verify results.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.5. Resolve a bug.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.5.1. Investigate a reported bug.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.5.2. Reproduce a bug.   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.5.3. Evaluate the affect of the bug and the associated cost and timeline for fixing the bug.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

5.5.4. Fix a bug.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6. Deploying and Supporting an Application   [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.1. Evaluate the performance of an application that is based on the performance analysis strategy. [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.1.1. Identify performance spikes.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.1.2. Analyze performance trends.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.1.3. Track page response times.   [Exam 71-547 only (and 70-551)]

6.1.4. Track logon times.   [Exam 71-547 and 71-548 only (and 70-551 and 70-552)]

6.2. Analyze the data received when monitoring an application. [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.2.1. Monitor and analyze resource usage.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.2.2. Monitor and analyze security aspects.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.2.3. Track bugs that result from customer activity.  [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.2.4. Choose when to use ASP.NET 2.0 Health Monitoring APIs.   [Exam 71-547 only (and 70-551)]

6.3. Evaluate the deployment plan. [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.3.1. Identify component-level deployment dependencies.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554)]

6.3.2. Identify scripting requirements for deployment.    [Exam 71-547, 71-548, and 71-549 (and 70-551, 70-552, and 70-554); 71-548 and 71-549 (and 70-552 and 70-554) add “Considerations include database scripting.”]

6.3.3. Evaluate available deployment methods.    [Exam 71-548 only (and 70-552)]

6.4. Create an application flow-logic diagram.    [Exam 71-547, 71-548, and 71-549 (and 70-554)]

6.4.1. Evaluate the complexity of components.   [Exam 71-547, 71-548, and 71-549 (and 70-554)]

6.4.2. Evaluate the complexity of interactions with other components. [Exam 71-547, 71-548, and 71-549 (and 70-554)]

6.5. Validate the production configuration environment. Considerations include load balancing, Web farms, and Web gardens.   [Exam 71-547, 71-548, and 71-549 (and 70-551 and 70-552); 71-548 and 71-549 (and 70-552) do not have “Considerations include …”]

6.5.1. Verify networking settings.  [Exam 71-547, 71-548, and 71-549 (and 70-551 and 70-552)]

6.5.2. Verify the deployment environment.   [Exam 71-547, 71-548, and 71-549 (and 70-551 and 70-552 [twice])]