Although currently software development often separates the design phase from the implementation, the trend towards model-driven approaches is undeniable. As models are the primary development artifact in model-driven development, one has to deal with the problems surrounding huge and therefore unmanageable models. To tackle these issues, systems are often divided into components that are modeled separately. As an alternative, views can be used, which hide certain aspects of the model or present them in a different form. In both cases, several models or at least several views co-exist, which leads to the problem of model synchronization. One of the main goals of model-driven development is the automatic generation of executable applications. Here, too, model synchronization is problematic, as several information sources may affect the same code fragment. When only parts of the system are generated, the remaining application has to be coded by hand, which complicates the reapplication of the generation process. In order to achieve a high level of automation in model-driven development, the complete application has to be modeled. In this scenario, the use of several models improves understandability and precision but again leads to model synchronization issues. In this dissertation I extend and concretize the ideas presented in [AK00] and [AK03]. In [AK00] Atkinson and Kühne introduced the concept of stratified architectures. With it, software systems are described by a number of strata with decreasing levels of abstraction. Each stratum introduces a concern and thereby concretizes the system description. This strict ordering limits dependencies to adjacent strata. In [AK03] the authors complement the concept by using annotations to describe each concern. By introducing “refinement transformations”, which implement abstractly described concerns, annotations enable stepwise refinement for model based system development and, in addition, alleviate the aforementioned model synchronization issue. In my thesis I discuss similar approaches and compare them to architecture stratification. Additionally, I present a complete implementation of the stratification concept and verify its effectiveness by applying it to a real-world project. The central element is a combined graphical and textual model transformation language, which optimally fits the needs for stepwise refinement in a model-driven environment. This language enables fine grained and highly parameterizable model transformations. They are organized in concern-oriented transformation rules and described using a detailed metamodel. The rules are presented using a notation, which employs activity diagrams for the control flow and collaboration diagrams for the model transformation. The language also integrates a template-based code generation language and can be extended further by using hand-written code. It is integrated into a CASE tool and provides the ability to trace concerns and their implementations within a stratified architecture. [AK00] Colin Atkinson and Thomas Kühne. Separation of Concerns through Stratified Architectures. International Workshop on Aspects and Dimensions of Concerns, ECOOP 2000, Cannes, France, 2000. [AK03] Colin Atkinson and Thomas Kühne. Aspect-Oriented Development with Stratified Frameworks. IEEE Software, 20(1):81-89, 2003.