Once the process of analyzing and gathering requirements is completed (well...at least one iteration), then it's possible to proceed to the next phase: building the application.
-Modelling has to do with designing the technical architecture in detail. From use cases it’s possible to create object models and sequence diagrams to describe the static and dynamic nature of the application.
-Here there is a need to create deployment diagrams that describe the tiers and processing nodes required to support the application.
-During this process there is a need to create the information architecture and illustrate how it ties to the data dictionary, navigation features and content types into a cohesive site map.
-The information architecture is created with the use of user scenarios, storyboards and site maps that precisely describe the interface before the project moves to the build stage.
-The Interface Design is driven by the use cases that describe the requirements of system.
-Using the same documents as input to both the Interface and Technical Designs ensures that the system is consistent from front to back.
-During the build phase, designs are translated directly into source code so the application mirrors the business environment directly.
-Object model programs are developed to model the business environment, transaction programs to update the model, web pages to present the model, databases to store the model, and connectors to integrate other systems.
-It is good practice to develop automated unit tests in parallel with the application and run them in order to ensure that new code doesn't break existing code.
-Simple structural rules are coded directly into business object programs.
-Complex logic that affects several business objects is coded into transaction programs.
-Transaction programs are layered on top of the business object programs.
-The site map and interactive architecture are used to render web pages that create the look and feel of the system.
-Input validation and other simple business rules are coded directly into the web pages to improve the user's experience. These pages are integrated with server-side business logic to deliver advanced business applications across the Internet.
-All non-trivial web applications must work with other business systems.
-These systems include relational databases, transaction monitors, mainframe applications and third-party systems.
-In addition to the automated unit tests created during the build phase, it’s possible to test the complete business functions of the application at the end of each iteration.
-The application is deployed to the test environment so capacity and resiliency testing can be performed.
-Installing the application in the test environment at the end of each iteration forces operations staff to take ownership of the application long before the application is released to end users.
-Operations scripts and processes can be developed in parallel with the application, which reduces the overall duration of the project.
-During the test phase, defect reports are collected and analyzed.
-Defects in early iterations can be avoided in later iterations.
-During the deployment phase the application makes the transition to its user's community, which includes manufacturing, delivering, training, supporting, and tuning the application until the users are satisfied.
-Once the application is deployed, warranties and service level agreements come into play to ensure the ongoing success of the application.
-Training materials are developed to help users make the transition to the new application.
-Finally operations scripts are developed to manage the application.