Quality Attributes – A Primer

Quality is the most common word used everywhere.. In software development this is the most talked about word. I wanted to list out the most important attributes of quality related to Design, Run Time and Usability.

Design Quality Attributes


Availability defines the proportion of time that the system is functional and working.

Availability is measured as a percentage of the total system downtime over a predefined period.

Typical factors affecting availability are System Errors, Infrastructure issues and System Load.

Things to Consider:

  • Load and Throughput of the system. Always design for 50x capacity, Implement for 3x, Deploy for 1x.
  • System Resiliency. Consider using the Circuit Breaker or Bulkhead patterns to increase system resiliency.
  • Inappropriate use of resources & Concurrency. Acquire resource late and release early.
  • Have a good exception handling mechanism to reduce application failures from which it is difficult to recover.
  • Always design for network faults and unreliable network connections.  A network fault can cause the application to be unavailable.
  • Consider the trust boundaries within your application and ensure that subsystems have some form of access control or firewall, as well as extensive data validation, to increase resiliency and availability.

Conceptual Integrity

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

A coherent system is easier to maintain because you will know what is consistent with the overall design.

Things to Consider:

  • Separate areas of concern within the system and group them into appropriate layers (Business/Data/Service)
  • Establish a standard development process including published guidelines, standards for design and coding and a review process to make sure the published guidelines and standards are followed.
  • Isolate applications from external dependencies.
  • Create a migration plan for legacy systems and consider using the Gateway design pattern for integration with legacy systems.


Maintainability is the ability of the system to undergo changes with a degree of ease.

Things to Consider

  • Avoid tight coupling/ dependencies between components and layers. Consider implementing cross-layer dependencies by using abstractions (such as abstract classes or interfaces) rather than concrete classes, and minimize dependencies between components and layers.
  • Strive for creating pluggable architecture (Eg.PRISM).
  • Do not create custom implementations for authentication & authorization. Use standards and built in functions/tools always.
  • Separation of concerns. Always plan for change and keep the volatile changes separately. Keep the business rules/process/logic separately in its own layer.
  • Have proper documentation of the design and interactions.


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

Things to Consider

  • Create a health model that defines the significant state changes that can affect application performance, and use this model to specify instrumentation requirements.
  • Implement instrumentation, such as events and performance counters, that detects state changes, and expose these changes through standard systems such as Event Logs, Trace files, or WMI.
  • Create an Application management pack which provides accurate monitoring, debugging and management of the system.


Performance is an indication of the responsiveness of a system to execute specific actions in a given time interval. It can be measured in terms of latency or  throughput.

Latency is the time taken to respond to any event.

Throughput is the number of events that take place in a given amount of time.

Things to Consider:

  • Reduce cross process communication using coarse-grained interfaces which require minimum number of calls to execute a specific task.
  • Use Asynchronous communication as often as possible.
  • Design an efficient and appropriate caching strategy.
  • Choose effective types of transactions, locks, threading, and queuing .
  • Avoid fetching all data only  when a portion of the data is displayed.
  • Design for high performance communication between tiers by reducing the number of transitions across boundaries  and minimizing the amount of data sent over the network.


Reliability is the ability of a system to continue operating in the expected way over time. Reliability is measured as the probability that a system will not fail and that it will perform its intended function for a specified time interval.

Things to Consider:

Identify ways to detect failures and automatically initiate a failover, or redirect load to a spare or backup system.

  • Implement instrumentation, such as events and performance counters, that detects poor performance or failures of requests sent to external systems.
  • Always Log performance and auditing information about calls made to other systems and services.
  • Identify ways to handle unreliable external systems, failed communications, and failed transactions.
  • Consider how you can take the system offline but still queue pending requests.
  • Implement store and forward or cached message-based communication systems that allow requests to be stored when the target system is unavailable, and replayed when it is online.


Reusability is the probability that a component will be used in other components or  scenarios to add new functionality with little or no change. Reusability minimizes the duplication of components and the implementation time.

Things to Consider:

  • Examine the application design to identify common functionality, and implement this functionality in separate components that you can reuse.
  • Examine the application design to identify crosscutting concerns such as validation, logging, and authentication, and implement these functions as separate components.
  • Use platform agnostic data types and structures that can be accessed and understood on different platforms.


Scalability is ability of a system to either handle increases in load without impact on the performance of the system, or the ability to be readily enlarged.

There are two methods for improving scalability:

Scaling vertically (scale up) – You add more resources such as CPU, memory, and disk to a single system.

Scaling horizontally (scale out) –  To scale horizontally, you add more machines to a farm that runs the application and shares the load.

Things to Consider

  • Consider partitioning data across more than one database server to maximize scale-up opportunities and allow flexible location of data subsets.
  • Avoid stateful components and subsystems where possible to reduce server affinity.
  • Consider how you will handle spikes in traffic and load.
  • Consider implementing code that uses additional or alternative systems when it detects a predefined service load or a number of pending requests to an existing system.
  • Implement store-and-forward or cached message-based communication systems that allow requests to be stored when the target system is unavailable, and replayed when it is online.


Security is the capability of a system to reduce the chance of malicious or accidental actions outside of the designed usage. The features used to secure systems are authentication, encryption, auditing, and logging

Things to Consider:

  • Use authentication and authorization to prevent spoofing of user identity. Identify trust boundaries, and authenticate and authorize users crossing a trust boundary.
  • Damage caused by malicious input such as SQL injection and cross-site scripting. Protect against such damage by ensuring that you validate all input for length, range, format, and type using the constrain, reject, and sanitize principles.
  •  Encode all output displayed to users.
  • Data tampering. Partition the site into anonymous, identified, and authenticated users and use application instrumentation to log and expose behavior that can be monitored.
  • Use instrumentation to audit and log all user interaction for application critical operations.
  • Design all aspects of the application to prevent access to or exposure of sensitive system and application


Supportability is the ability of the system to provide information helpful for identifying and resolving issues when it fails to work correctly.

Things to Consider:

  • Use common components to provide tracing support.
  • Capture and report sufficient information about errors and state changes in order to enable accurate monitoring, debugging, and management.


Testability is a measure of how well system or components allow you to create test criteria and execute tests to determine if the criteria are met. Testability allows faults in a system to be isolated in a timely and effective manner.

Things to Consider:

  • Design systems to be modular to support testing.
  • Provide instrumentation or implement probes for testing, mechanisms to debug output, and ways to specify inputs easily.
  • Start testing early during the development life cycle. Use mock objects during testing, and construct simple, structured test solutions.
  • Automate user interaction tests, and how you can maximize test and code coverage.
  • Input and output inconsistencies; for the same input, the output is not the same and the output does not fully cover the output domain even when all known variations of input are provided. of test cases.

User Experience / Usability

The application interfaces must be designed with the user and consumer in mind so that they are intuitive to use, can be localized and globalized, provide access for disabled users, and provide a good overall user experience.

Things to Consider:

  • Too much interaction (an excessive number of clicks) required for a task.
  • Ensure  you design the screen and input flows and user interaction patterns to maximize ease of use.
  • Incorrect flow of steps in multistep interfaces.
  • Data elements and controls are poorly grouped. Choose appropriate control types and layout controls and content using the accepted UI design patterns.
  • Use asynchronous techniques for background tasks, and tasks such as populating controls or performing long-running tasks.

Source : Application Architecture Guidelines