Systems Integration and Architecture

Name: Rocas, Ron Iverson C. Date: 17/9/23

Section: IT301
Instruction: Do the following written assignment.
1. Phase Analysis (2 days): Research and provide a detailed explanation of each phase of the
SDLC (e.g., Planning, Analysis, Design, Implementation, Testing, Deployment, and
Maintenance). Describe the goals, activities, and deliverables associated with each phase.
1. Planning Phase
The SDLC's first stage, the Planning Phase, is when the project's goals and scope are
established. The main objective is to fully comprehend the project's requirements, limitations,
and viability. This phase's activities include obtaining specific needs from all relevant parties,
conducting feasibility studies to evaluate the project's technical, operational, and financial
viability, and planning resource allocation, including people and material resources, budgets,
and schedules. The project schedule, which lists due dates and milestones, as well as the project
scope document, feasibility report, and resource allocation plan, are important deliverables.
2. Analysis Phase
The Analysis Phase, which comes after the Planning Phase, focuses on examining the
gathered requirements to determine the functional and non-functional needs for the software.
The main objective is to fully comprehend user requirements and to clarify and complete them.
To design the data structure and linkages, activities include data modeling, user interviews,
surveys, and extensive requirement analysis. A system requirements definition, data model
diagrams, user personas, and use cases that describe how the software will interact with users
are among the deliverables from this phase.
3. Deisgn Phase
A comprehensive blueprint for the sotfware is developed during the design phase, which
also deals with system architecture, database design, and user interface design. The objective is
to turn the requirements into an actual implementation strategy. The entire system architecture
is defined at this phase, together with the database schemas and data flow diagrams, and the
user interface is designed using wireframes and prototypes. System architectural diagrams,
database schemas, and user interface mockups are examples of important deliverables that
clearly show the structure and design of the product.
4. Implementation Phase
By creating the software and writing the actual code based on the specifications
established in earlier phases, the implementation step brings the concept to life. The creation of
an operational software system is the main objective. The code is written, tested, and debugged
by developers, and integration operations join separate parts and modules to form a seamless
whole. The source code and an integrated version of the software that is ready for testing are
the main outputs from this phase.
5. Testing Phase
The Testing Phase's goal is to find and fix errors so that the software works properly and
complies with the requirements. Unit testing, integration testing, and system testing are just a
few of the testing stages that are involved. These tests assess how well each component
performs individually, how well components interact with one another, and how well the system
behaves. Deliverables include thorough test strategies, in-depth test scripts and scenarios, and
defect reports that highlight problems discovered during testing.
6. Deployment Phase
The goal of the deployment phase is to gradually and methodically push out the
program to users. The software must be installed and configured on the target servers, end
users and support personnel must be trained, and data migration from the old system may be
essential. To ensure a smooth transfer to the new system, key deliverables include the deployed
software, training materials, and data migration logs.
7. Maintenance Phase
The maintenance phase guarantees the software's long-term health and functionality.
Goals include fixing reported issues, putting improvements into place, and keeping an eye on
and improving system performance. Continuous bug fixes, the addition of new features or
upgrades, and performance monitoring are all activities. To keep the program up-to-date and
trustworthy, deliverables include bug reports and patches, updated documentation, and version
updates.

2. SDLC Models (2 days): Compare and contrast different SDLC models such as Waterfall, Agile,
and DevOps. Explain the advantages and disadvantages of each model. Provide examples of
when each model is best suited for a project.
1. Waterfall Model
A conventional and linear method of software development is the waterfall model. Its
benefits come from being structured and systematic, which makes it simple to comprehend and
use. It functions best when project specifications are clear and consistent from the start,
enabling a linear progression through phases including planning, design, development, testing,
and deployment. Additionally, it emphasizes thorough documentation strongly, which helps
with ongoing maintenance and comprehension. The lack of adaptability to new requirements
after moving on to the next phase can be a disadvantage, and the introduction of testing and
user feedback later than necessary can result in expensive adjustments. Waterfall is frequently
appropriate for smaller projects with clear goals and available tools.
2. Agile Model
The Agile Model is a great option for projects with changing or unclear needs since it is
flexible and adaptable. By emphasizing early and continuous software delivery, it encourages
regular evaluation and adaptation based on feedback. Agile encourages tight communication
across cross-functional teams, but it faces difficulties in scaling for large and complicated
projects and places a great deal of reliance on a highly competent and self-organized team for
implementation success. Additionally, Agile frequently favors usable software over thorough
documentation, which may not be appropriate in many situations. Agile works effectively for
projects where it is advantageous to release a smaller portion of the product fast in order to
gather feedback and make necessary course corrections.
3. DevOps Model
The DevOps Model focuses on improving communication between development and
operations teams. It specializes in providing software in a timely and reliable manner. DevOps
accelerates product iterations by shortening development cycles and streamlining the
development process. However, for successful implementation, it may at first demand a lot of
work and cultural adjustments within a company. Professionals with expertise in both
operations and development are crucial. Additionally, if not well managed, the quick pace of
DevOps might occasionally ignore important security problems. DevOps is especially well-suited
for projects that strive for faster, continuous delivery of high-quality software, especially in
large-scale projects with complicated infrastructure and the requirement for quick adaptability
to changes.
3. Role of Systems Integration and Architecture (2 days): Explain how systems integration and
architecture play a vital role in each phase of the SDLC. Describe the impact of integration and
architecture decisions on the overall success of a project.
1. Planning Phase
It's critical to comprehend the requirements for integration throughout the planning
stage. It entails determining how the new software will work with already installed programs,
databases, and outside services. Lack of integration planning may result in compatibility
problems and higher project risks.
Major architectural choices are taken at the planning stage. These choices specify the
project's overarching framework and technology stack. The architecture chosen affects the
project's budget, scalability, and capacity to achieve its goals. Poor architectural decisions now
can result in expensive rework later.
2. Analysis Phase
 In this stage, integration requirements are in-depthly analyzed. Formats for data sharing,
protocols, and security issues must all be defined. For proper estimation of project schedules
and resource requirements, integration dependencies must be understood.
More architectural concerns are covered in the analysis phase. The development of data
models, database schema designs, and system component requirements. These choices affect
user experience, system performance, and data management. A project's success may be
hampered by ineffective architecture caused by inadequate analysis.
3. Design Phase
Integration plans are made that outline the data sharing and communication between
various software components. This stage entails creating middleware, designing integration
routines, and creating APIs. Data discrepancies and unreliable connections might result from
poor integration design.
Detailed architectural design is done, including component interactions, infrastructure
needs, and the construction of architectural diagrams. These plans act as development's
building blocks. A system that doesn't satisfy performance, security, or scalability goals may
have flawed architectural designs.
4. Implementation Phase
Integration code is created during implementation in accordance with integration
specifications. The accuracy and dependability of these integrations directly affect how well the
program interacts with other systems. System failures and data damage can result from
incomplete or flawed integrations.
Software developers put the architectural plans into practice. Coding techniques, such as
code structure, technology selections, and scalability considerations, are guided by architectural
decisions. A codebase can become inconsistent and inefficient when architectural rules are
broken.
5. Testing Phase
During this stage, integration testing is crucial. It makes sure that the external systems
and integrated components communicate effectively. Comprehensive integration test scenarios
find problems with communication, compatibility, and data sharing. Integrity issues and
inconsistent data might occur after a release if integration testing is neglected.
The testing strategy is influenced by architectural decisions. It could be important to
perform performance testing to make sure the architecture can support the anticipated loads.
System instability and performance bottlenecks may result from ignoring this factor.
6. Deployment Phase
 To guarantee a smooth transition to production, integration considerations are essential
throughout deployment. To prevent hiccups in the live environment, integrations with external
systems must be tested and verified.

The deployment approach is influenced by architectural choices. System dependability

and scalability in the production environment are directly impacted by decisions about server
configurations, load balancing, and redundancy. Poorly designed deployments may cause
disruption and financial loss.
7. Maintenance Phase
As external systems change, maintenance frequently entails updating and improving
integrations. Long-term success depends on making sure the software can adjust to changes in
external dependencies.
The maintainability and scalaiblity of the software are still impacted by architectural
choices. Optimization of the architecture to boost performance, the addition of additional
components, or meeting changing business requirements are all examples of maintenance
activities. Architectural issues might be overlooked during maintenance, which can result in
technical debt and higher operating expenses.