DEV Community: Moataz Nabil

Platform Engineering with AWS: What You Need to Know

Moataz Nabil — Thu, 27 Mar 2025 20:19:36 +0000

Imagine you're working at a fast-growing tech company with multiple development teams. At first, everything runs smoothly—developers write code, deploy it manually, and handle infrastructure as needed. But as the company scales, things get complicated.

Developers struggle to manage different environments. One team runs its services on EC2; another uses Kubernetes, and a third experiments with Lambda. Setting up a new service becomes a hassle, requiring multiple Slack messages, Jira tickets, and DevOps support.

Security updates often take a backseat to feature development—until something breaks.

Instead of focusing on building features, developers spend too much time fixing pipelines and troubleshooting infrastructure.

This chaos slows innovation and creates bottlenecks.

A dedicated Platform Team can solve these issues by building a self-service Internal Developer Platform (IDP). This platform streamlines infrastructure, automates deployments, and enforces best practices, allowing developers to focus on what they do best—writing code.

By 2026, 80% of large software engineering organizations will establish platform engineering teams as internal providers of reusable services, components, and tools for application delivery — up from 45% in 2022. Gartner

What is Platform Engineering?

Platform engineering is creating an Internal Developer Platform (IDP) to facilitate software development and deployment.

Instead of each team handling infrastructure independently, a dedicated platform team builds and manages standard tools, automation, and best practices.

Without a dedicated Platform Team, organizations often encounter:

Lack of Standardization – Development teams may utilize inconsistent tools, CI/CD pipelines, and infrastructure, resulting in inefficiencies.
Increased Cognitive Load on Developers – Engineers have to manage infrastructure, deployments, and security configurations rather than focusing on feature development.
Slow Developer Onboarding – Without an Internal Developer Platform (IDP), new engineers are slower to become productive due to fragmented tools and unclear workflows.
Operational Bottlenecks – SREs and DevOps teams become overwhelmed as developers depend on them for environment provisioning, debugging, and scaling.
Security and Compliance Risks – Without a centralized approach, enforcing security policies, access controls, and compliance becomes more challenging.
Inefficient Incident Management – Debugging production issues takes longer when a unified observability and monitoring framework is absent.

Key Principles of Platform Engineering

Platform engineering is a vital discipline that focuses on designing, creating, and maintaining the underlying systems and infrastructure that support a range of software applications and services. This field encompasses several key principles that guide platform engineers in their work, ensuring scalability, reliability, and efficient resource management:

Platform as a Product – Consider the platform as a dynamic product, gather developer insights, and enhance it continuously.
Developer Experience (DevEx) – Provide self-service tools to minimize friction.
Developer Happiness – Lower cognitive load, eliminate obstacles, and allow engineers to concentrate on innovation.
Faster Feedback Loops – Facilitate rapid iterations and seamless delivery.
Golden Pathways – Establish best software building and deployment practices.
Automation & Observability – Implement Infrastructure-as-Code (IaC), monitoring, and auto-scaling to ensure operational efficiency.

These principles help teams overcome challenges and set long-term goals for a better development workflow.

Now, let’s dive into Platform Engineering with AWS and how it improves the developer experience.

AWS Services for Platform Engineering

AWS offers vast services to create a highly scalable and automated developer platform. This platform enables developers to streamline workflows, enhance productivity, and accelerate application development through various tools and resources.

The key areas include:

Infrastructure as Code (IaC) & Automation: - Use CloudFormation, CDK, or Terraform for infrastructure provisioning. Automate CI/CD workflows with CodePipeline and GitHub Actions. Or use Terraform, an Open-source IaC tool for resource management.

Enable Developer Self-Service: - Provide standardized templates and blueprints. Use the AWS Service Catalog to let teams easily spin up environments. This integration allows for the efficient building, testing, and deployment of applications directly from a GitHub repository to various AWS services, ensuring that code changes are reflected in production with speed and accuracy

CI/CD & DevOps Automation - Integrate GitHub Actions with AWS for seamless deployments.

Containerization & Orchestration - Amazon ECS (Elastic Container Service) provides managed container orchestration, enabling users to easily run and scale containerized applications. Amazon EKS (Elastic Kubernetes Service) offers Kubernetes management on AWS, simplifying the deployment and management of Kubernetes clusters. Additionally, AWS Fargate allows for serverless computing for containers, removing the need for infrastructure management and letting users focus on their applications.

Observability & Monitoring: - Building strong observability from the start is essential, which can be achieved using CloudWatch, X-Ray, and OpenTelemetry for monitoring purposes. Implementing structured logging with centralized storage helps in maintaining comprehensive oversight. Amazon CloudWatch provides a place for logs, metrics, and alarms in one location. AWS X-Ray offers distributed tracing designed explicitly for microservices, while the AWS OpenSearch Service facilitates log analytics and search functionality. Additionally, Prometheus and Grafana on AWS are powerful open-source monitoring tools that can be utilized for enhanced observability.

Security & Governance: - Enforce security from day one by applying IAM least privilege policies and automating security compliance with AWS Config and Security Hub. AWS IAM (Identity and Access Management) is crucial for controlling access and permissions, while AWS Organizations and Control Tower help manage multi-account governance. Additionally, AWS Security Hub provides centralized security insights, and AWS Secrets Manager and Parameter Store ensure secure credential storage.

Optimize for Cost & Performance: - Use AWS Compute Savings Plans & Spot Instances for cost efficiency. Implement auto-scaling to match demand dynamically.

For example, here is how to build Developer Portals with Backstage and Amazon EKS Blueprints - Source AWS

The AWS architecture diagram above illustrates the deployment of Backstage, an open-source developer portal, within an Amazon EKS (Elastic Kubernetes Service) cluster.

Users access Backstage through a domain managed by Amazon Route 53, with traffic routed via an Elastic Load Balancer that secures connections using SSL certificates from AWS Certificate Manager.

The Backstage application runs inside the EKS cluster and relies on Amazon RDS for PostgreSQL as its database.

Sensitive credentials, such as database credentials, are securely stored in AWS Secrets Manager and accessed by the application through an External Secrets mechanism, which syncs them into Kubernetes Secrets.

Backstage retrieves these credentials to connect to the database.

Additionally, container images for Backstage are stored in Amazon ECR, ensuring efficient deployment and scalability.

Overall, this architecture leverages AWS-managed services to provide security, scalability, and ease of management for hosting Backstage in a Kubernetes environment.

It’s crucial to understand how to measure Platform Engineering's success so we can improve it and ensure we're on the right path.

Measuring the Success of Platform Engineering

To measure the effectiveness of Platform Engineering and IDP, organizations should track several key metrics.

For developer productivity, they should consider the lead time for changes (DORA metric), deployment frequency, time to onboard new developers, and the time spent on non-coding tasks, such as setting up environments.

Regarding operational efficiency, organizations should monitor the Mean Time to Recovery (MTTR), the number of support tickets related to CI/CD or environments, and the time spent on infrastructure maintenance.

Developer satisfaction and adoption can be assessed through Developer NPS (Net Promoter Score), self-service adoption rates for deployments, provisioning, and debugging, and feedback from internal surveys.

Additionally, quality and stability metrics include the number of failed deployments, incident resolution time, and improvements in test coverage.

Finally, for security and compliance, organizations should track the number of security vulnerabilities identified and remediated, along with compliance adherence rates.

Final Thoughts

Platform Engineering with AWS empowers teams to construct scalable, self-service, and developer-friendly environments tailored to their unique needs.

By effectively leveraging a suite of AWS services—including Amazon Elastic Kubernetes Service (EKS), Amazon Elastic Container Service (ECS), AWS Lambda, Terraform for infrastructure as code, AWS CodePipeline for continuous integration and delivery, Amazon CloudWatch for monitoring, and AWS Identity and Access Management (IAM) for security management—teams can significantly enhance their operational efficiency.

This strategic use of AWS tools increases developer productivity by streamlining workflows and automating processes, ultimately allowing developers to focus on innovation rather than maintenance.

Additionally, these capabilities reduce operational headaches, facilitating smoother project execution and faster time-to-market for applications.

In essence, Platform Engineering with AWS fosters a modern development environment and creates a robust foundation for future growth and scalability within organizations.

Helpful Resources:

Thank you for reading

The key responsibilities of a Software Quality Manager: ensuring high-quality software development

Moataz Nabil — Sun, 06 Aug 2023 16:37:40 +0000

The key responsibilities of a Software Quality Manager: ensuring high-quality software development

In the ever-changing landscape of software development, delivering efficient and top-notch products is vital for achieving success. The Software Quality Manager (SQM) plays a central role in upholding quality throughout the development journey.

In this blog post I will uncover the essential duties of a Software Quality Manager and explore the significant impact they have on the software development process.

Test planning and management

Comprehensive test planning is essential for ensuring a well-structured testing process. SQMs collaborate with stakeholders to define testing objectives, scope, and priorities. They create detailed test plans, including test cases, data, and environments.
Through meticulous test management, SQMs ensure that testing progresses smoothly and is aligned with project timelines.

Implementing effective testing strategies

Testing lies at the heart of software quality assurance, and a Software Quality Manager leads the charge in implementing effective testing strategies. This includes designing comprehensive test plans, defining test cases, and overseeing the execution of various testing phases, such as unit testing, integration testing, and user acceptance testing.

A well-executed testing strategy helps identify and rectify defects early in development, saving time and resources in the long run.

Software Quality Assurance (SQA)

Software Quality Assurance is a proactive approach to ensure quality processes are in place throughout the software development lifecycle. SQMs establish SQA methodologies, conduct process audits, and monitor adherence to best practices.
By focusing on prevention rather than detection, SQA minimizes defects and ensures that quality is ingrained in every stage of development.

Quality assurance tools and automation play a significant role in enhancing the efficiency and effectiveness of software testing. SQMs are responsible for evaluating, selecting, and implementing the right quality assurance tools that align with the project's requirements.

These tools help streamline testing processes, increase test coverage, and ultimately lead to a more reliable and high-quality software product.

Quality management

As the keepers of quality, SQMs are responsible for defining and measuring quality metrics. They analyze these metrics to gain insights into the development process and continuously make data-driven decisions to improve overall software quality.
Effective quality management helps the development team stay on track and identify areas for improvement.

Setting and Enforcing Quality Standards by establishing clear and measurable quality standards for the development team to follow. These standards encompass various aspects, such as coding practices, testing methodologies, documentation requirements, and performance metrics. By enforcing these standards consistently, SQMs ensure that the entire development team adheres to best practices, resulting in a more robust and reliable software product.

How do Software Quality Managers measure and analyze quality metrics?

Software Quality Managers use a variety of metrics to measure and analyze the quality of software products throughout the development lifecycle. These metrics help them understand the health of the project, identify areas for improvement, and make informed decisions to ensure a high-quality end product.

Here are some common steps they take to measure and analyze quality metrics:

Define Quality Goals: Quality Managers work with stakeholders to define clear and measurable quality goals for the project. These goals should be aligned with the overall business objectives and customer expectations.
Identify Key Performance Indicators (KPIs): Quality Managers select specific KPIs that align with the defined quality goals. KPIs may vary depending on the project and technology, but some common examples include defect density, test coverage, code churn, customer satisfaction, and response time.
Set Baseline Metrics: Before the development process begins, a baseline set of metrics is established to provide a starting point for comparison. Baseline metrics help in evaluating the progress and improvements made over time.
Collect Data: Throughout the development lifecycle, relevant data is collected from various sources such as testing tools, version control systems, issue tracking systems, performance monitoring tools, and customer feedback channels.
Analyze Trends: Quality Managers analyze trends in the collected data to identify patterns or changes that could affect product quality. They look for trends that might reveal potential risks or opportunities for optimization.
Conduct Root Cause Analysis: When issues or defects arise, Quality Managers perform root cause analysis to understand the underlying reasons for the problems. This helps in implementing corrective actions and preventing similar issues in the future.
Use Test Automation: Automation tools play a significant role in measuring quality metrics. Automated tests provide continuous feedback on the quality of the code and help maintain consistency in the testing process.
Use Test Management Tools: Test management tools, such as TestRail help Quality Managers organize test cases, track test execution, and gather test results. These tools assist in collecting valuable data for quality analysis.
Collaborate with Development Teams: Quality Managers work closely with development teams to understand the challenges they face and identify potential improvements in the development process that could enhance quality.
Report and Communicate: Quality Managers compile their findings into comprehensive reports and communicate the results to stakeholders, project managers, and development teams. These reports help in decision-making and driving improvements.
Continuously Improve: Quality Managers use the insights gained from quality metrics to continuously improve processes, tools, and workflows, aiming for incremental enhancements in product quality.

Testing domains and types

Software projects often encompass various testing domains and types, such as functional testing, performance testing, security testing, and more. SQMs possess an in-depth understanding of these testing areas and allocate resources accordingly. They ensure the appropriate testing types are executed to mitigate risks and deliver a robust, reliable product.

Test Automation and tooling

Test automation has become a cornerstone of efficient and effective software testing. SQMs are responsible for identifying suitable automation tools and frameworks, creating automated test scripts, and integrating them seamlessly into the development process. Automated testing increases test coverage and allows faster and more frequent testing, enabling rapid feedback on code changes and reducing time-to-market.

What are some common coding practices, testing methodologies, documentation requirements, and performance metrics that SQMs enforce?

The following are a few common coding practices, testing methodologies, documentation requirements, and performance metrics SQMs enforce in their test automation frameworks:

Coding Practices:

Code Reviews: encourage regular code reviews to ensure that the code follows coding standards, is maintainable, and doesn't introduce critical defects.
Coding Standards: enforcing consistent coding standards helps improve code readability, maintainability, and reduces the risk of introducing errors.
Code Refactoring: encouraging code refactoring helps in keeping the codebase clean, organized, and easier to maintain over time.

Testing Methodologies:

Test-Driven Development (TDD): advocate for TDD, where tests are written before the actual code. This helps in designing code that meets the specified requirements and prevents defects.
Continuous Integration (CI): CI involves frequent integration of code changes into a shared repository and automated builds and tests. SQMs ensure that CI pipelines are in place to maintain code quality and detect issues early.
Unit Testing: enforce the practice of writing unit tests to verify the correctness of individual code components.
Regression Testing: enforce the practice of running regression tests whenever changes are made to the code to ensure that existing functionality remains intact.
Integration Testing: Integration testing is essential to verify the interactions between different components of the software. SQMs ensure that integration tests are part of the testing process.
Performance Testing: emphasize performance testing to assess how well the software performs under different load conditions.

Documentation Requirements:

Requirements Documentation: ensure that clear and comprehensive requirements are documented, providing a basis for testing and development efforts.
Test Plans and Test Cases: enforce the creation of detailed test plans and test cases to ensure complete test coverage.
Code Documentation: promote documenting code to explain its purpose, logic, and usage for better understanding and maintenance.

Performance Metrics:

Defect Density: the number of defects found per lines of code or functional points is a measure of code quality.
Test Coverage: test coverage measures the percentage of code or requirements covered by tests, helping to assess the completeness of testing efforts.
Mean Time to Detect (MTTD) and Mean Time to Resolve (MTTR): these metrics track how quickly defects are detected and resolved, respectively.
Response Time: for applications and systems, response time measures how quickly the software responds to user actions or requests.

What specific automation tools and frameworks do Software Quality Managers typically use?

Software Quality Managers typically use a variety of automation tools and frameworks to streamline and enhance the software testing and quality assurance processes.

The specific tools and frameworks used may vary depending on the organization's needs, technology stack, and preferences. Here are some commonly used automation tools and frameworks:

Web Testing:

Selenium WebDriver
Cypress
Playwright
WebDriverIO

Mobile Testing:

Appium
Espresso (Android)
XCUITest (iOS)
Maestro
Detox (React Native)
Flutter Integration Test

Unit Testing:

JUnit (Java)
TestNG (Java)
NUnit (.NET)
Pytest (Python)
Mocha (JavaScript)

Behavior-Driven Development (BDD): Cucumber (with Gherkin language)

API Testing:

Postman
SoapUI
REST Assured (Java)

Load Testing and Performance Testing:

JMeter
LoadRunner
Gatling

Continuous Integration and Continuous Deployment (CI/CD):

GitHub Actions
Azure Pipelines
GitLab CI/CD
CircleCI
Codemagic
AWS CodePipeline
Jenkins

Test Management and Issue Tracking:

JIRA
TestRail

Cross-Browser Testing:

BrowserStack
Sauce Labs
LambdaTest

Code Quality and Static Analysis:

SonarQube
ESLint (JavaScript)

Desktop Application Testing:

WinAppDriver (Windows)

Security Testing:

OWASP ZAP (Zed Attack Proxy)

Test Data Management: Faker (for generating test data programmatically)

It is possible that new tools have emerged in the landscape of software testing tools. The tools used by Software Quality Managers may also vary depending on the requirements and technology stack of the projects they manage.

Leadership and communication

Leadership skills are critical for SQMs, as they collaborate with diverse cross-functional teams and provide guidance throughout development. They inspire their teams to achieve excellence, foster a culture of continuous improvement, and resolve conflicts when they arise. Effective communication ensures that quality objectives, progress, and challenges are transparently communicated to stakeholders, fostering alignment and trust.

Collaborating with cross-functional teams

Software development is a collaborative effort involving multiple cross-functional teams, including developers, testers, designers, product managers, and more. The SQM is pivotal in fostering effective communication and collaboration among these teams.

By maintaining a clear line of communication and facilitating regular meetings, SQMs ensure that all stakeholders are aligned on quality objectives and are working cohesively towards achieving them.

Continuous process improvement

SQMs are not just concerned with immediate quality goals; they also focus on continuous process improvement. By analyzing software development metrics and gathering feedback from team members, they identify areas for enhancement and optimize the development process iteratively. Continuous process improvement fosters a culture of learning and innovation, leading to more efficient and streamlined development cycles.

Risk management and mitigation

In any software project, inherent risks impact quality and project timelines. A Software Quality Manager works proactively to identify these risks, assess their potential impact, and develop risk mitigation strategies. By taking a proactive approach to risk management, SQMs help prevent quality issues before they arise and ensure that the software development process stays on track.

A Day in the Life of a Manager in Quality Engineering

As a Manager in Quality Engineering, your day will be a dynamic mix of overseeing team members, coordinating with other departments, strategizing, and ensuring the quality of the software development process. Here's a glimpse of what a typical day might look like:

Check Emails and Reports: start your day by reviewing emails and automated test reports from the previous day. Address any urgent issues and assign tasks to team members accordingly.
Daily Stand-Up: hold a daily stand-up meeting with your quality engineering team. Each team member provides a brief update on their ongoing tasks, challenges, and any required assistance. Use this opportunity to reinforce project goals and clarify expectations.
Project Planning: meet with the development team leads and project managers to discuss upcoming software releases or new features. Understand the requirements and plan the test strategy, including identifying areas suitable for automation.
Review Test Scripts: review the automated test scripts created by your team members. Ensure they adhere to coding standards, are maintainable, and provide adequate test coverage for the application under test.
Team Support: provide support and guidance to team members, whether addressing technical issues, offering testing advice, or helping with scripting challenges.
Process Improvement: identify opportunities to improve the efficiency and effectiveness of the quality engineering process. Collaborate with your team to discuss ideas and implement improvements to streamline testing efforts.
Cross-Functional Meetings: meet stakeholders from other departments, such as Development, Product Management, and Operations. Discuss ongoing projects and potential bottlenecks, and align everyone on quality goals.
Automation Framework Enhancements: work with your team to enhance the existing automation framework, integrating new tools or libraries that can improve testing capabilities and efficiency.
Documentation and Reporting: ensure that test documentation, including test cases, test results, and automation scripts, is current. Prepare comprehensive reports on the testing progress and test coverage for management and other stakeholders.
Skill Development: encourage your team members' professional growth by identifying relevant training or certifications, discussing career goals, and providing mentorship.
Review Project Status: before the end of the day, check in with the team members to get updates on their progress. Address any critical issues or blockers that may affect project timelines.
Plan for Tomorrow: take some time to plan the priorities for the next day, assign tasks, and ensure that your team has the necessary resources to carry out their responsibilities.
Personal Development: dedicate some time to your professional development, whether reading articles on the latest trends in quality engineering, attending webinars, or networking with industry peers.

Wrap up the day ensuring that your team feels supported and informed and that the overall quality engineering efforts are on track. Leave the office with a sense of accomplishment, knowing you've contributed to the success of the software development process through adequate quality assurance and automation management.

Conclusion

The role of a Software Quality Manager is multi-faceted and essential in maintaining and enhancing software quality throughout the development lifecycle. By overseeing test automation and tooling, test planning and management, SQA, quality management, testing domains, testing types, leadership, and communication, SQMs play a critical role in delivering high-quality software products.

Their expertise impacts efficiency, early defect detection, product quality, adaptability, and continuous improvement, ensuring organizations thrive in a competitive software development landscape.

Embracing the expert touch of a Software Quality Manager is a strategic move toward successful software delivery and customer satisfaction, essential for organizations seeking to excel in the competitive software development landscape.

Thanks for reading and happy testing!

Cloud Test Automation on AWS: The Role of QA Engineers

Moataz Nabil — Sun, 25 Jun 2023 09:30:04 +0000

In today's rapidly evolving technological landscape, cloud computing has become an integral part of businesses across various industries. With the growing reliance on cloud services, ensuring their quality and performance has become paramount. This is where Quality Assurance (QA) Engineers with expertise in test automation on the AWS platform come into play.

In this blog post, we will explore the key skills and experiences required for a QA Engineer focusing on test automation in a cloud environment, specifically AWS.

Test planning and execution

The ability to create comprehensive test plans and perform manual testing is vital. Additionally, the creation and execution of automated tests are essential skills in ensuring efficiency and accuracy in the QA process.

Programming or scripting language proficiency

A QA Engineer should be proficient in at least one programming or scripting language such as Java, GoLang, Bash, or Python. This proficiency enables them to write and maintain test automation scripts, making the QA process more efficient and scalable.

Experience with Cloud technologies

To excel in the role of a QA Engineer in the cloud domain, it is crucial to possess relevant experience with cloud technology. This experience provides a solid foundation and understanding of the unique challenges and intricacies associated with cloud-based systems.

Deployment and troubleshooting of SaaS in AWS

A QA Engineer should be well-versed in the deployment and troubleshooting processes of Software as a Service (SaaS) applications on AWS. This involves understanding the AWS infrastructure, managing resources, and effectively resolving issues that may arise during the deployment and operation of SaaS solutions.

DevOps tools in a cloud environment

QA Engineers should be comfortable working with various DevOps tools commonly used in a cloud environment. This includes tools such as Docker, Helm Charts, Kubernetes, and SonarQube.

These tools facilitate efficient development, testing, and deployment processes, enabling seamless collaboration between development and operations teams.

CI/CD pipelines and IaC

Familiarity with CI/CD pipelines such as AWS CodePipeline and IaC (Infrastructure as a Service) such as AWS CloudFormation or Terraform is crucial for streamlining the software development and deployment processes.

CI/CD pipelines allow for continuous integration and delivery, ensuring that changes are thoroughly tested before being deployed. IaC, on the other hand, simplifies infrastructure management, making it easier to provision and configure resources in a cloud environment.

Building and maintaining systems on Kubernetes

Kubernetes has emerged as a leading container orchestration platform. QA Engineers with experience in building and maintaining systems on Kubernetes possess the necessary skills to ensure the smooth operation and scalability of applications in a cloud environment.

Understanding microservices architectures

Having knowledge about microservices architectures, serverless, and related concepts is highly beneficial. This includes understanding chaos testing techniques with AWS Fault Injection Simulator.

Microservices play a crucial role in modern cloud-based applications, and being well-versed in their architectures and associated practices allows QA Engineers to test and validate the system effectively.

Additional useful skills

The following skills and experiences would be considered advantageous:

AWS certification - Possessing an AWS certification demonstrates a deep understanding of the AWS platform and its services, further validating the QA Engineer's expertise in cloud testing.
Agile development methodology - Familiarity with agile development methodologies, such as Scrum or Kanban, enhances collaboration, adaptability, and iterative development practices within a QA team.
Security and secrets management - Experience with tools like AWS Secrets Manager, AWS Key Management Service (KMS), AWS Web Application Firewall (WAF) for secure secrets management and overall system security adds an extra layer of expertise to the QA Engineer's skill set.
Generative AI services - Knowledge of Artificial Intelligence (AI) services such as Amazon CodeWhisperer generates Code in Python, Java, JavaScript, TypeScript, SQL, and 10 More Language which increase the testing and QA productivity and reduce the development hours.
Cloud SQL and NoSQL databases - Experience with cloud SQL databases, such as Amazon RDS and Amazon DynamoDB enable QA Engineers to thoroughly test and validate the data storage and retrieval processes.
Monitoring solutions - Familiarity with monitoring solutions like Amazon CloudWatch and AWS CloudTrail allows QA Engineers to proactively identify and address performance issues, ensuring optimal system functionality.

Conclusion

Being a QA Engineer focused on test automation in a cloud environment, particularly on AWS, requires a diverse skill set encompassing cloud technology, test planning and execution, proficiency in DevOps tools, knowledge of microservices architectures, and programming/scripting language expertise.

By continuously adapting to the evolving landscape of cloud computing, QA Engineers play a crucial role in ensuring the quality, performance, and reliability of cloud-based systems, contributing to the success of organizations embracing the cloud revolution.

Happy testing!

Unveiling my first book "Mobile DevOps Playbook": Your Handbook for Faster, High-Quality Mobile App 📱🚀

Moataz Nabil — Thu, 27 Apr 2023 08:41:21 +0000

Mobile app developers know that staying ahead in the game means delivering high-quality applications quickly and efficiently. As someone who has experienced the challenges of mobile app development firsthand, I am excited to share that my first book, titled , "Mobile DevOps Playbook: A practical guide for accelerating the delivery of high-quality mobile applications., has been published by Packt! The book is now open for pre-orders globally on Amazon. 🎉

In this post, I'll provide a brief overview of the book, discuss some key topics covered, and explain how "Mobile DevOps Playbook" can help you and your team elevate your mobile app development process.

Book Overview:

"Mobile DevOps Playbook" is a comprehensive guide that dives into the world of Mobile DevOps, offering practical strategies, tools, and techniques to speed up the delivery of top-notch mobile applications. Published by PACKT Publishing, this book is tailored for mobile app developers, DevOps practitioners, and teams aiming to optimize their app development and deployment processes.

Key Topics:

Grasping Mobile DevOps: Understand the fundamentals of Mobile DevOps, the advantages of embracing this approach, and how it diverges from traditional DevOps.
CI/CD for Mobile Apps: Learn to implement Continuous Integration and Continuous Deployment pipelines in your mobile app development process to boost efficiency and minimize errors.
Mobile Test Automation: Uncover best practices for designing and managing automated tests to guarantee your mobile apps are dependable, secure, and fulfill user expectations.
App Performance Monitoring & Optimization: Recognize the significance of monitoring your mobile apps' performance, pinpoint bottlenecks, and explore tools available for optimizing app performance.
Effective Team Collaboration: Delve into strategies for nurturing collaboration within your team, such as clear communication, shared code repositories, and code review practices.

Benefits of "Mobile DevOps Playbook":

Whether you're a DevOps Engineer wanting to learn more about Mobile DevOps to build effective processes for releasing mobile apps quickly and frequently, this book is perfect for you. Furthermore, the book is an excellent resource for Mobile Developers, Mobile Release Managers, Mobile Architects, Mobile Platform Engineers, and QA Engineers who are involved in mobile app development, "Mobile DevOps Playbook" offers valuable insights and practical advice to help you:

Boost your team's efficiency and productivity
Cut down the time needed to deliver exceptional mobile applications
Identify and tackle common challenges in mobile app development
Streamline your app development and deployment processes using industry-standard tools and techniques

Conclusion:

I'm excited to share my expertise and experience in mobile app development and DevOps through "Mobile DevOps Playbook." I hope this book will be a useful resource for developers and teams looking to supercharge their mobile app delivery process.

Grab your copy of "Mobile DevOps Playbook: A practical guide for accelerating the delivery of high-quality mobile applications" on Amazon now and embark on a journey towards a more effective and efficient mobile app development process!

Happy coding and reading! 📚💻

Moataz Nabil

The Most Beneficial AWS Services for QA Engineers

Moataz Nabil — Tue, 27 Dec 2022 17:11:09 +0000

QA engineers can use AWS services to automate and streamline their testing processes and ensure that their applications are ready for deployment.

The purpose of this article is to highlight the most beneficial AWS services for QA and Test engineers and why they are beneficial.

Sounds interesting! Let's get started

Compute Category

1- Amazon EC2

Amazon EC2 (Elastic Compute Cloud) is a web service that provides resizable computing capacity in the cloud. It allows QA engineers to test applications and systems in a variety of environments, including different operating systems, hardware configurations, and network configurations.

Image Source - AWS

A benefit of using Amazon EC2 for QA is the ability to quickly spin up and down testing environments. In this way, QA engineers can efficiently test new features, fix bugs, and perform regression testing.

Furthermore, Amazon EC2 offers a wide range of instance types and sizes. This allows QA engineers to choose the right amount of computing power and memory for their testing needs. A variety of storage options are also available, including Amazon EBS (Elastic Block Store) for persistent data storage and Amazon S3 (Simple Storage Service) for object storage.

2- Amazon Lightsail

The Amazon Lightsail cloud computing platform lets developers and businesses manage virtual private servers (VPSs). The service offers a simple, scalable solution for hosting websites, applications, and data at a lower cost than Amazon Web Services (AWS).

One of the main benefits of using Amazon Lightsail for QA is the ability to set up and tear down environments quickly and easily. This means that QA engineers can test different configurations and environments without the need for physical hardware or lengthy setup processes.

You can use Amazon Lightsail to create an e-commerce website for test automation practices, more details can be found here

Create your e-commerce website for test automation using Amazon Lightsail and PrestaShop

3- AWS Lambda

AWS Lambda is a serverless computing platform that lets you run code in response to specific events. Lambda allows QA engineers to test their code and applications without having to setup and maintain their own infrastructure in a serverless environment.

Image Source AWS

Lambda requires some knowledge of programming and cloud computing. Besides setting up an AWS account, you will also need to install the necessary AWS CLI. After setting up your environment, you can create a Lambda function and specify the events or triggers that will invoke it. As soon as the specified events or triggers occur, your Lambda function will execute the code you wrote.

AWS Lambda can be used to run the automated test scripts with Selenium WebDriver, Playwright or Cypress on scale on the cloud quickly and efficiently.

Containers Category

4- Amazon Elastic Container Service (ECS)

Amazon Elastic Container Service (ECS) is a fully managed container orchestration service that allows QA engineers to run and manage Docker containers on AWS. With ECS, QA engineers can easily test the containerized applications with minimal effort.

Image Source - AWS

5- Amazon EKS

EKS or Elastic Container Service for Kubernetes is a managed service that makes it easy to deploy, manage, and scale containerized applications using Kubernetes. EKS is fully compatible with the open-source Kubernetes API, so you can use the same tools and plugins that you use with any other Kubernetes deployment.

Image Source - AWS

As a QA engineer, you can use EKS to test your applications in a Kubernetes environment without having to set up and maintain your own Kubernetes cluster. EKS takes care of the underlying infrastructure, so you can focus on testing your applications.

EKS offers a number of features that can be useful for QA engineers, including:

Automatic scaling: EKS automatically scales your clusters up or down based on demand, so you can test your applications under a range of load conditions.
High availability: EKS automatically replicates your applications across multiple availability zones to ensure high availability.
Integration with other AWS services: EKS integrates with other AWS services, such as Amazon RDS and Amazon EBS, allowing you to easily deploy and manage your applications in the cloud.

Application Integration Category

6- Amazon SQS

Amazon Simple Queue Service (SQS) is a fully managed message queueing service that enables you to decouple and scale microservices, distributed systems, and serverless applications. It makes it easy to build and maintain asynchronous workflows, allowing you to send, store, and receive messages between services, without having to worry about the underlying infrastructure.

Image Source - AWS

As a QA engineer, you can use Amazon SQS to test various aspects of your application's performance and reliability. Here are a few examples of how you can use Amazon SQS in your QA testing:

Load testing: You can use Amazon SQS to send a large number of messages to your application, to test how it handles high levels of traffic and concurrent requests. This can help you identify bottlenecks and performance issues, and optimize your application for scalability.

Integration testing: You can use Amazon SQS to simulate different service dependencies, and test how your application interacts with other components of your system. This can help you ensure that your application integrates seamlessly with other services and that it can handle failures and other errors gracefully.

Automated testing: You can use Amazon SQS to automate your testing processes, by setting up triggers and rules to run tests based on certain conditions. For example, you can use Amazon SQS to trigger a test whenever a new message is added to the queue, or whenever a message is processed by your application.

7- Amazon SNS

Amazon Simple Notification Service (SNS) is a cloud-based messaging service that enables QA engineers to send and receive messages and notifications between distributed systems, servers, and clients. With SNS, QA engineers can quickly test and debug the communication and messaging capabilities of their applications and systems.

Image Source - AWS

Some potential use cases includes:

Sending notifications to a QA team when a new build or release is ready for testing.
Receiving alerts when there are issues or failures in the application during testing
Sending messages to trigger automated testing scripts or processes
Receiving notifications when certain events or thresholds are reached in the application (e.g. high traffic, error rate, etc.)

SNS offers a range of delivery options, including SMS, email, mobile push notifications, and more, making it easy for QA engineers to test and validate the messaging capabilities of their applications.

Database Category

8- Amazon RDS

RDS or Relational Database Service is a fully managed database service provided by Amazon Web Services (AWS) that makes it easier to set up, operate, and scale a relational database in the cloud. It supports a variety of popular database engines, including MySQL, PostgreSQL, and Microsoft SQL Server, and allows you to choose the configuration and resource capacity that best fits your needs.

Image Source - AWS

You can use Amazon RDS to set up test environments for your applications, run database performance tests, and perform data integrity checks. Some of the tasks you might perform when testing an application with Amazon RDS include:

Setting up multiple test environments with different database engines and configurations
Populate test databases with sample data
Running database queries and analyzing the results to verify the accuracy and performance of the application
Performing database backups and restores to test the reliability and recoverability of the application
Ensuring data integrity by running tests to verify the correctness of database transactions and constraints

Storage Category

09- Amazon S3 (Simple Storage Service)

Amazon S3 (Simple Storage Service) is a cloud storage service provided by AWS. It is designed to store and retrieve large amounts of data quickly and efficiently.

Image Source - AWS

Amazon S3 can be used to store test data and test results. This allows QA engineers to easily access and analyze data from different test environments and iterations. For instance you can send use generate test reports using Allure report on the CI server and send the files to S3 bucket to use it as a static website to displaying the test results.

Developer Tools

10- AWS CodeCommit

AWS CodeCommit is a fully managed version control service that makes it easy for QA engineers to store, track, and collaborate on code. With CodeCommit, QA engineers can easily create and manage Git repositories, view and compare code changes, and review and merge code changes with others. CodeCommit also integrates seamlessly with other AWS services, such as AWS CodeBuild and AWS CodePipeline.

Image Source - AWS

11- AWS CodeBuild

CodeBuild is a fully managed build service that compiles source code, runs tests, and produces artifacts that are ready for deployment. QA engineers can use CodeBuild to automate the build and test process for their applications.

Image Source - AWS

This service allows you to build, test, and deploy your applications quickly and efficiently. You can use it to automate the build process, run tests, and deploy your applications to various environments.

12- AWS CodePipeline

CodePipeline is a continuous delivery service from AWS that helps automate the build, test, and release process. QA engineers can use CodePipeline to set up automated testing as part of the release process, ensuring that code changes are thoroughly tested before they are deployed to production. It allows for automated testing and deployment of code changes, ensuring the quality and reliability of applications.

Image Source - AWS

Front-end Web & Mobile Category

13- AWS Device Farm

AWS Device Farm is a cloud-based testing service that allows you to test your mobile and web applications on a wide range of devices. It provides access to a variety of physical devices for testing applications on real hardware.

You can use Device Farm to test your applications on real devices, including smartphones, tablets, and desktop computers, running different versions of operating systems and browsers.

Image Source - AWS

Device Farm offers a number of features that can be useful for QA engineers, including:

Wide range of devices: Device Farm has a large pool of devices that you can choose from, including popular smartphones and tablets running Android, iOS, and other operating systems.
Remote access: Device Farm allows you to remotely access the devices and interact with them as if you were physically using them, making it easier to debug and troubleshoot issues.
Supports different test automation framework such as XCTest
XCTest UI for iOS, Instrumentation for Android, or cross-platform such as Appium.

Also there are built-in testing types such as UI Automator, explorer (Android) and fuzz (Android and iOS).

Related Resources

Thank you for reading and happy testing!

Getting started with Appium 2.0: Your beginner’s guide

Moataz Nabil — Tue, 20 Dec 2022 14:59:25 +0000

A hands-on guide to help you to get started with Appium 2.0, the new features, and how to install and use it locally or on Bitrise.

What’s Appium?

Appium is an open-source project and ecosystem of related software, designed to facilitate UI automation of many app platforms, especially for mobile apps such as iOS, Android, and Flutter.

Using Appium, you can automate your UI testing across any number of platforms in a standard way. Many tools allow UI automation on platforms, but these are typically platform-specific native tools such as Espresso for Android and XCUITest for iOS and require specific programming language knowledge and toolchains.

The Appium framework aims to integrate all these automation technologies into a stable interface accessible through the most popular programming languages including Java, Python, Ruby, C#, and Javascript.

Overview of Appium 2.0

Appium 2.0 (still beta) reenvisions Appium as a platform where “drivers” and “plugins” can be easily created and shared independently.

Drivers: gives you the ability to install and work with de-coupled drivers based on your application platform (iOS, Android, Windows OS, Flutter, such as Espresso driver “appium driver install espresso”.
Plugins: gives you the ability to modify the Appium framework by adding new features via plugins and through integrations with other technologies such as the images plugin: “appium plugin install images”, then activate the plugin with your server by “appium --use-plugins=images”
Appium Desktop: is still available, but now comes in two packages:
- Appium Desktop (Server)
- Appium Inspector

With Appium 2.0, you should also ensure you’re sending W3C standard capabilities within your test code such as the following capabilities:

{
  "platformName": "Android",
  "appium:platformVersion": "9",
  "appium:deviceName": "emulator-5554",
  "appium:automationName": "Espresso",
  "appium:app": "app-debug.apk"
}

Getting started with Appium 2.0

Before getting started with Appium v2 you need to know the requirements, then with Appium 2.0 you need to follow the following steps:

Step 1: Install Appium v2

npm install -g appium@next

NOTE: Currently, you must use appium@next instead of just appium. Once Appium 2.0 has been officially published, you can simply use appium.

To make sure which appium version is installed, run the following command:

appium -v

The output should be 2.0.0-beta.46

After installing Appium v2 you will have the ability to extend the CLI with plugin and driver commands.

Step 2: Install an Appium driver and its dependencies
To install the Appium driver and its dependencies, we'll be using the Espresso, XCUITest, and Flutter drivers.

appium driver install espresso
appium driver install xcuitest
appium driver install flutter

To make sure that all the drivers are installed successfully, run the following command:

appium driver list

Step 3: Install the plugins
To install the plugins, run the following command to get a list of the available plugins and then install any of them:

appium plugin list

To install any plugin, such as images, use the following command:

appium plugin install images

And to use it with the Appium server, use the following command:

appium --use-plugins=images

To run the Appium Server, use the Server GUI or the command line, for example:

appium server -ka 800

Or the GUI application:

And if you want to inspect the elements, you need to open the Inspector application:

Step 4: Install the Appium client library
Install an Appium client library in your language or choice (we’ll be using the Java client with Maven).

Step 5: Run an Appium automation script
Write and run a simple Appium automation script using a sample application.

public class AppiumAndroidTest {
    public static AppiumDriver driver;

    @BeforeClass
    public void Android_setUp() throws MalformedURLException {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("appium:automationName", "espresso");
        capabilities.setCapability("appium:platformVersion", "9");
        capabilities.setCapability("appium:deviceName", "Android Emulator");
        capabilities.setCapability("platformName", "Android");
        capabilities.setCapability("appium:app", System.getProperty("user.dir") + "/apps/app-debug.apk");
        driver = new AndroidDriver(new URL("http://127.0.0.1:4723"), capabilities);
    }

    @Test
    public void calcDemo(){
        driver.findElement(By.id("buttonFive")).click();
        driver.findElement(By.id("buttonAdd")).click();
        driver.findElement(By.id("buttonFour")).click();
        driver.findElement(By.id("buttonEqual")).click();
    }

    @AfterClass

    public static void tearDown() {
        if (null != driver) {
            driver.quit();
        }
    }
}

You can find the full project in this GitHub repository.

Now, you can run your project locally, but as you know it’s required to have an Android Emulator and iOS Simulator installed.

The Appium Troubleshooting Guide
Using appium-doctor, you can verify your installation and manually install anything that is missing if necessary.

You will notice that appium-doctor is deprecated

And you can install it using the following command as mentioned here:

npm install @appium/doctor -g

You can check the iOS and Android setup by running the following command:

appium-doctor
If something is wrong, you can fix it manually and run the command again.

If you are facing issues with Appium with iOS apps — or can’t run your tests on iOS real devices — check out how to set up iOS real devices and also Enable the Developer Mode on the device.

If you are facing a problem with the WebDriverAgent — or can’t be installed on the device — you can also try to locate the Xcode project. Add your team account in the code signing setting and try to build the app for an iOS device to make sure that there is no problem.

You can use the following command to find the project directory:

echo "$(dirname "$(find "$HOME/.appium" -name WebDriverAgent.xcodeproj)")"

And the output will give you the path of the project

Open the project in Xcode, add a team or your developer account and build the project to make sure that there is no issue with the WebDirverAgent.

Migration from Appium 1.x to Appium 2.x

Here is a guide that walks you through some potential breaking changes and other useful tips for migrating your test code from Appium 1.x to Appium 2.x.

Utilize Bitrise's CI/CD Workflow to run Appium tests

Bitrise and Appium integrate seamlessly. You can run your test automation with Appium on virtual devices in the cloud without needing to use a 3rd party cloud service.

For testing mobile applications on Bitrise and Appium, you’ll be able to:

Integrate test automation into your CI/CD pipelines.
Multiple platforms can be used to scale your existing Appium testing.
Using the Test Report add-on to find and fix bugs faster.

The integration is simple and straightforward, I created a Bitrise integration step to simplify the installation of the Appium Server, Drivers (XCUITest, Espresso, and Flutter) and run the server as a background task.

You need only to add the Step in your Bitrise Workflow and in case you need to run UI tests on Android you need to spin up the emulator first but with iOS, the execution will initialize the Simulator.

Run the UI tests via the Maven command

Copy the Appium Log to the Deploy directory to view it via the Artifacts section

Finally, export the test results to the Test Report add-on.

Run the Build and the results should be like the following images.

Congratulations 🎉, you have successfully run your Android and iOS test cases with Appium v2 on Bitrise.

Resources

In this section, you'll find links to additional Appium resources around the web, including my Appium course with Test Automation University.

Appium Resources

Getting started with Maestro: The new mobile UI testing framework from Mobile.dev

Moataz Nabil — Fri, 09 Dec 2022 15:55:58 +0000

This article shows you how to use the Maestro UI testing framework to write the tests and run them locally or on the cloud.

Today, test automation is not a nice feature, especially when it comes to mobile apps since there is a lot of competition on the market and we are increasingly relying on mobile apps, which adds more pressure to release quality mobile apps quickly.

And also if you are planning to implement CI/CD pipelines in your team, you need to know that Test Automation now is a vital part of this process and without it, you can’t release your products frequently.

There are many tools and frameworks available, from native to cross-platform, and you should choose one that suits your team and application.

Because of that, in this article, I’d like to share my thoughts about the new mobile UI testing framework from Mobile.dev, it’s Maestro.

Sounds good! Let’s get started!

What is Maestro?

Maestro is the simplest and most effective open-source mobile UI testing framework developed by Mobile.dev. It’s built on learnings from its predecessors (Appium, Espresso, UIAutomator, XCTest) and allows you to easily define and test your Flows (the user journey in the app or you can say the E2E scenarios).

Maestro is yaml based which means you are defining the test flows inside a flow.yml file and can run it on the devices.

Maestro has different features such as

Flakiness is tolerated by design. In Maestro, the unstable nature of mobile apps and devices is accommodated and UI elements are deconstructed to counter the instability.
No need to call sleep() repeatedly in your tests. The Maestro knows that loading the content may take some time (for example: over the network) and waits for it automatically (but not too long).
There is no need to compile anything because tests are interpreted. As your test files change, Maestro automatically reruns them.
Maestro supports native (Android and iOS) and cross-platform mobile platforms (Flutter and React Native).

Getting started with Maestro

You can install Maestro on macOS and Linux with the default install instructions but on Windows, you need to follow these steps.

The Pre-requests:

For iOS, install the Facebook IDB tool:

brew tap facebook/fb
brew install facebook/fb/idb-companion

Booted Android Emulator.
Booted iOS Simulator.

Then you can install the Maestro CLI using the following command:

curl -Ls "https://get.maestro.Mobile.dev" | bash

After that run the following command

export PATH="$PATH":"$HOME/.maestro/bin"

To make sure it’s installed successfully you can check the version with the following command

maestro -v

With Maestro CLI you will have different options such as

test: run the flow on your local machine.
cloud: run the flow on Maestro Cloud.
upload: upload the app and the flow file to Maestro Cloud.
query: find an element that matches a condition.
hierarchy: prints out the whole view hierarchy that is currently being shown in the app
download-samples: download sample projects for demonstration.
login: login to your Maestro Cloud account.
logout: logout from your Maestro Cloud account.

Writing your first Flow

In my demo, I will use a simple login Android application but the same concepts can be applied to the other platforms because it’s the same logic.

1- Goto the application folder and create a new folder

mkdir .maestro

2- Create a flow yaml file for example flow.yaml

If you are using sublime

subl flow.yml
Or you can use touch command

touch flow.yml

The scenario that I need to cover is:

1- Open the application, clear the state and stop the app if it’s running.
2- Enter the Email in the textbox.
3- Enter the Password in the textbox.
4- Assert that the Login button is visible.
5- Take a screenshot of the main screen.
6- Click on the Login button.
7- Take a screenshot after login in successfully.
8- Stop the app.

3- Open the flow yaml file to add the following steps:

appId: de.moataz.maestro.demo
---
- launchApp:
    appId: "de.moataz.maestro.demo"
    stopApp: true
    clearState: true

In the above section, we launch the app using the appId and also stop it if it’s already running and clear the State to avoid flakiness as much as we can.

To enter the Email and the Password we need to use InputText and TapOn commands

- inputText: "moataz@gmail.com"
- tapOn: "password"
- inputText: "123456"

💡TIP: You can use random Emails or Texts instead of entering them so the above code will look like this:

- inputRandomEmail
- tapOn: "password"
- inputRandomText

Let’s complete the example with the following code:

- assertVisible: "SIGN IN OR REGISTER"
- takeScreenshot: MainScreen
- tapOn: "SIGN IN OR REGISTER"
- takeScreenshot: LoggedInScreen
- stopApp

In the above code, we are verifying that the Login button is visible or displayed and take a screenshot before clicking on the button then take another screenshot after this action and finally close or stop the application.

So the full example will be like the following code:

appId: de.moataz.maestro.demo
---

- launchApp:
    appId: "de.moataz.maestro.demo"
    stopApp: true
    clearState: true

- inputRandomEmail
- tapOn: "password"
- inputRandomText
- assertVisible: "SIGN IN OR REGISTER"
- takeScreenshot: MainScreen
- tapOn: "SIGN IN OR REGISTER"
- takeScreenshot: LoggedInScreen
- stopApp

Run the Flow

Before running the Flow you need to build and install the app on the Emulator/device by the following commands:

./gradlew clean assembleDebug
adb install app/build/outputs/apk/debug/app-debug.apk
If the app is successfully installed on the device you can run the Flow, from the command line using the following command:

maestro test .maestro
It will run the Flow, along with any other yaml files you have.

And you will notice that the screenshots added to the project directory.

Run the tests with a test report

If you need a JUnit report for your tests you can do it easily by running the following command:

maestro test --format junit .maestro
And you will find a report.xml file in the project directory. and if you need to override the file name you can use the following command:

maestro test --format junit --output results.xml .maestro
Open the results.xml file and you will find the results like the following screenshots

The report helps you to troubleshoot the Flow for example if you didn’t install the app you will find this failure.

Furthermore, if you did not boot the emulator, you will see a list of the devices that are available on our machine and you can write the number to boot the device, as shown in the screenshot below.

Run the Flow on Maestro Cloud

Maestro Cloud is another great feature from Mobile.dev for Maestro, which runs your Flows in the cloud without the need to configure any simulators or emulators. You can easily integrate Maestro Cloud into your existing CI workflows this way.

Among the features of Maestro Cloud are

Parallel Test Execution.
Managed iOS simulators and Android emulators.
Screen Recordings.
Maestro Command Output.
Application Logs.

You must first create an account here in order to run the Flows on Maestro Cloud because you need an API Key from the Console, click on your email and copy the API Key.

Or you can log in from the command line using the following command:

maestro login
And then run the test using the following command:

maestro cloud --apiKey .maestro/

In my case, it will be like

maestro cloud app/build/outputs/apk/debug/app-debug.apk .maestro/
Using this command, you will upload the binary file, startup Android Emulator, and run the Flow.

Go to the Maestro Cloud Console to check the run results as displayed in the following screenshots

In addition, you can check the app startup performance, app size, memory leak, or Flow performance.

Bitrise 💜 Maestro

Bitrise is a Mobile DevOps platform that helps mobile developers deliver secure mobile apps faster with good quality. Hence, we are happy to announce that the Maestro UI framework can now be run with Bitrise Integration from Mobile.dev which allows you to run the Flows on Maestro Cloud quickly and easily.

It's time to get started!

I’m assuming that you have your Android application configured on Bitrise, if you don’t have one you can follow the instructions here.

First, you need to add your Maestro Cloud API Key as a Secret on Bitrise.

Add the Maestro Integration Step and configure the input configuration.

And the whole workflow will be like the following screenshot

After the build has been successfully completed, you can review the Maestro integration step and you will notice that the app and the Flow uploaded to the Maestro Cloud and you can check the results on the Maestro Console.

Congratulations 🎉 you learn how to use the Maestro UI testing framework and run it as a part of your CI workflow with Bitrise.

In this repository, you'll find both the demo app and the entire bitrise.yml file.

This was the first part and in the next article, we will cover the following topics:

Set up Pull Request integration with GitHub.
Use multiple Flows at once.
Add the Memory Leak Analysis.
Maestro Record.

Resources

Maestro by Mobile.dev
Integrate Maestro into Bitrise
GitHub - mobile-dev-inc/maestro: Painless Mobile UI Automation
Maestro Cloud
Introducing: Maestro — Painless Mobile UI Automation
Public Slack Channel, then join the #maestro channel.

Thank you for reading and happy testing!

Moataz

Create your e-commerce website for test automation using Amazon Lightsail and PrestaShop

Moataz Nabil — Tue, 06 Sep 2022 15:22:20 +0000

For most test automation engineers, it is necessary to have a demo website in order to simulate a real website including different functions and elements.

The majority of these websites are e-commerce websites because they have different features and you can automate the whole process and placing an order and create E2E scenarios from logging in to checking out.

What is the problem?

If you start practicing with a demo website, you may find the website is down the following day or week, and you cannot continue.

Because of that, I will show you how to create your own e-commerce website using Amazon Lightstail hosted on AWS and PrestaShop.

Sounds interesting!

Let's get started 🚀

What is Amazon Lightsail?

Amazon Lightsail is the easiest way to get started with AWS for developers, small businesses, students, and other users who need a solution to build and host their websites and web applications in the cloud.

Lightsail provides developers compute, storage, and networking capacity. Lightsail includes everything you need to launch your project quickly – virtual machines, containers, databases, CDN, load balancers, DNS management etc. – for a low, predictable monthly price. - Source: Amazon Lightsail FAQs

To start using Lightsail, choose Get Started and log in. You use your Amazon Web Services account to access Lightsail; if you don't already have one, you'll be prompted to create one.

Create your e-commerce website

1- Login with your AWS account and from the dashboard, select Amazon Lightsail service

2- Click on Create an instance

3- You can change the AWS Region and Availability Zone based on your preferences

4- Pick your instance image in our case we will select Linux VM

5- Select the blueprint and in our case we will choose Prestashop from the Apps + OS

6- You will connect to your instance using the default SSH key or you can create a new one

7- There is an option for the automatic snapshot but we can leave it for now and you can enable it afterwards.

8- Select the price tier but I will leave the default one. For a limited time, new Lightsail customers can try the selected plan for free for three months andn after that you can pay only 3.5 USD. Read more about the Lightsail pricing from here

7- Rename the instance name to be for example MyShop and click on Create instance button

8- Wait till the VM status to be running

9- Now you can access the the VM using SSH

10- After you're connected, enter the following command to get the default application password:

cat $HOME/bitnami_application_password
Save the password because you will use it to login as an administrator

For more information you can check the start guide for PrestaShop on Amazon Lightsail

11- Now you can open the instance with the public IP

12- If you want to login as an administrator you can use the following details:

URL: http://[YOUR_PUBLIC_IP]/administration
Username: user@example.com
password: YOUR_PASSWORD

Congratulations 🥳 , you now have your own e-commerce website where you can run your test automation scripts.

What's next?

Amazon Lightsail give you the ability to create and attach a Static IP, add additional storage, create a snapshot, check the Metrics and more.

And if you don't need the VM anymore you can delete it.

Resources

Frequently Asked Questions in Amazon Lightsail

Thanks for reading and happy testing! 🚀

Run your security static analysis tests for Android apps on the cloud with MobSF and AWS

Moataz Nabil — Mon, 29 Aug 2022 22:41:00 +0000

This article walks you through the steps of setting up the MobSF Scan tool on an AWS EC2 machine with Docker to be able to run your static analysis tests for Android apps easily.

As part of Droidcon Berlin this year, I spoke about DevSecOps for Android and how security testing can be injected into the CI/CD pipeline and Mobile DevOps.

In the presentation, I mentioned different automated security testing tools that we can use with Android.One of these tools is MobSF — it’s an open-source static analysis tool that can find insecure code patterns in your Android and iOS source code supports Java, Kotlin, Swift, and Objective C.

There is a live version of the tool and you can upload your APK and scan it — but what if you need to have your own version installed on your own server or machine?

Because of that, in this article, I will demonstrate how to run the MobSF Docker container on an AWS EC2 machine and use the API to upload the Android APK to the server to start the scanning process.

Sounds interesting? Let’s get started.

The prerequisites
This demo is required the following prerequisites:

[A free AWS account (https://portal.aws.amazon.com/billing/signup)
A free GitHub account
An Android application, you can fork the Insecure Shop app from GitHub and use it as a demo if you don’t have an Android app.

Now let’s build our solution.

1- Login to the AWS management console and select the EC2 service.

2- Click on Instance to launch a new Amazon Linux instance and make sure that’s under the free tier category.

3- Then select the instance type, key pair, and security group and make sure that you allow the HTTP or HTTPS to be able to access the machine from the browser beside the SSH.

4- Click Launch the instance and wait to tell it becomes ready to access.

5- You have a machine with public IP and also you can assign a domain name to it if you want.

6- Now the VM is ready and you can access it by clicking on the connect button. You can choose between different clients but I’m using the default one in this demo which is the EC2 Instance Connect.

7- We are inside the machine now and we can start using the shell to run the commands for instance: sudo yum update to install the updates

8- Now we need to install the Docker to be able to download and run the MobSF Docker container by the following command:

sudo yum install docker

9- Add group membership for the default ec2-user so you can run all Docker commands without using the sudo command:

sudo usermod -a -G docker ec2-user

id ec2-user

newgrp docker

10- Enable Docker service at AMI boot time:

sudo systemctl start docker.service
11- Get the Docker service status on your AMI instance, run:

sudo systemctl status docker.service

12- See the Docker version:

docker version

13- In the MobSF documentation, you can find how to install the Prebuilt Docker image by the following command:

docker pull opensecurity/mobile-security-framework-mobsf

docker run -it --rm -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest

Now Docker will start to pull the image and build the container and it will be linked to port 8000.

Because of that, we need to update our security group for this instance to add this port to be able to access it by editing the Inbound rules.

14- Now you can try to access the VM via the browser and the result should be like the following image:

Congratulations, you have successfully installed the MobSF tool on your machine.

Now you can upload the APK manually if you want to scan them or you can use the MobSF API from Mobile CI/CD platform such as Bitrise to upload the APK after you build the application then send it to the MobSF server that hosted on AWS machine.

Happy testing!

Mobile DevOps Summit on November 10th. Call For Speakers is now open!

Moataz Nabil — Wed, 10 Aug 2022 13:52:00 +0000

Mobile DevOps Summit 2022 is a one-day, free and virtual conference powered by Bitrise that brings together over 2500 mobile practitioners and global business leaders to discuss unique challenges faced by mobile teams.
Submit your talk and become a speaker to drive the conversation on how to build, test, release, monitor, and collaborate on mobile apps successfully.

Mobile DevOps Summit will cover topics such as:

How to approach mobile testing, debugging, and quality assurance
What mobile-specific performance metrics should be tracked?
How to perfect the app store release process for iOS and Android apps
How to engage more users and maximize the impact of your mobile app
What are the processes and best practices for mobile apps?

The complete program provides a holistic understanding of how to implement Mobile DevOps best practices in an organization.

Submit your talk here: https://sessionize.com/mobile-devops-summit-2022/

More information on the event is available here https://www.mobiledevops.io/summit

Alexa for CI/CD: Add Alexa Skill to Alexa for Business - Part 4

Moataz Nabil — Tue, 03 May 2022 16:33:06 +0000

In the last part of our Alexa for Bitrise tutorial series, you will learn how to publish Alexa Skills to Alexa for Business and use it with AWS Organizations. Let's dive in!

After you create, build, test, and integrate your skill with the AWS Lambda function you're ready to certify and publish your skill. In this tutorial, you will learn how to publish Skills to Alexa for Business.

Let’s get started!

Publish the skills

There are two different options to publish your skills with Alexa: public and private. Public means it will appear in the Amazon Alexa Skills Store. In this case, your skill must meet requirements for policy, security, functionality, voice interface, and user experience to receive a certificate. After your skill passes certification testing, you can publish your skill in the Amazon Alexa Skills Store.

But in our case, since our Skill is for development purposes and may not require to be published to the Skills Store, we will publish it as a Private Skill for our AWS Organization.

Publish the skill with private availability

To use the Amazon developer console to publish a private skill, you must have the following:

A skill Id for a skill that is under development (You have already one from Part 3)
The ARN for AWS Alexa for Business accounts to which you want to grant access to the private skill

What’s Alexa for Business?

Alexa for Business makes it easy for you to use Alexa in your organization. Alexa for Business provides tools to manage Alexa devices, enroll users, and configure skills across those devices.

Image Source - Alexa for Business

Note: Alexa for Business is available in the US only.

To be able to publish your Skills to Alexa for Business you should have AWS Organization to be able to assign the Skills to it.

AWS Organization helps you centrally manage and govern your environment as you grow and scale your AWS resources. Using AWS Organizations, you can create accounts and allocate resources, group accounts to organize your workflows, apply policies for governance, and simplify billing by using a single payment method for all of your accounts - AWS Organizations.

Image Source AWS Organizations - Amazon Web Services

Let’s now publish the Skill with the following steps:

Navigate to the Distribution page.
Make sure you have completed all fields in the Skill Preview section for language (English US).

You can select your favorite icons (I just used any simple icons for the demo)

Click Save and Continue button
Answer questions in the Privacy and Compliance section then click Save and continue button

For the Availability option, select Alexa for Business Organizations, then click Save and continue button.

You will navigate to the Certification page. Review and correct any validation errors. All validations must pass before you can submit the skill.

Click the Submission button, then click Submit for review button.

Once your skill has been published (privately) to the live stage, you can add the skill to a specific Alexa for Business organization.

You can manage the Alexa for Business organizations with access to your private skill from the Distribution > Availability section of the developer console. The Manage access to your skill section contains controls to add and remove organizations. The list of organizations that currently have access is displayed as well.

Well done!, you just published your first Alexa Skills to Alexa for Business, now it’s time to manage the access to the Skill from the Alexa for Business Console.

Manage skill access from the Alexa for Business console

Once you have set up the private skill for distribution, the customer whose account has been granted access can follow these steps to access the private skill:

Log in to the Alexa For Business console.
Navigate to the Skills > Private Skills tab. Select Review and then Enable the private skill.

Navigate to the Enabled Skills tab. Add the private skill to a skill group to enable the skill on devices in rooms containing that skill group. See the Alexa for Business administrators guide for more information.

Conclusion

My goal with this series was to learn the basics of AWS Lambda, design and build a Serverless function to trigger CI build for example Bitrise builds with Bitrise API via the custom Lambda function, design and build a custom Alexa skill, and finally publish the Alexa skills to the Alexa for Business service so we can use them with AWS Organizations.

Resources

Thank you for reading these articles!

Happy building!

Alexa for CI/CD: Putting it all together - Part 3

Moataz Nabil — Tue, 26 Apr 2022 10:49:36 +0000

In the previous two parts in this series, we created our Lambda function and the Alexa Skill. In this tutorial, we’ll learn how to connect Amazon Alexa Skill to the AWS Lambda function to trigger Bitrise builds via a voice user interface.

Sounds good? Let’s get started!

The solution

As we know AWS Lambda function needs to be triggered by any supported triggers. Because of this, we will use Alexa and Alexa Skill Kit (ASK) to trigger the function. Inside the function, we will add our logic to receive the voice command from Alexa and pass it to Bitrise API using the POST endpoint to trigger a new build in our Bitrise app. Then, we will get the response from Lambda to the Alexa as a JSON output.

Previously our Lambda function was using the following code to trigger the build via the POST endpoint:

var request = require('request');

let app_slug = process.env.APP_SLUG
let api_key = process.env.API_KEY

var options = {
  'method': 'POST',
  'url': 'https://api.bitrise.io/v0.1/apps/'+app_slug+'/builds',
  'headers': {
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    'Authorization': api_key
  },
  body: JSON.stringify({
   'build_params': {
      'branch': 'chapter-3',
      'workflow_id': 'primary'
    },
    'hook_info': {
      'type': 'bitrise'
    }
  })

};

exports.handler =  async function(event, response) {
  console.log(response.body);
  return "done..."
}

request(options, function (error,response) {
  if (error) throw new Error(error);
  console.log(response.body);
});

But with the Alexa Skill Kit, we need to change this handler and the code logic with something to work with the voice command and the Skill Kit by the following code:

var request = require('request');

exports.handler = (event, context, callback) => {

    try {
        if (event.request.type === 'LaunchRequest') {
            callback(null, buildResponse('Hello from Bitrise'));
        } else if (event.request.type === 'IntentRequest') {
            const intentName = event.request.intent.name;

            if (intentName === 'triggerBuild') {

                buildBitriseApp(function (err, result) {
                    if(!err) callback(null, buildResponse('The build was launched! make sure you take a look.'));
                    else callback(null, buildResponse("Please check your build logs. Something went wrong."));
                });
            } else {
                callback(null, buildResponse("Sorry, i don't understand"));
            }
        } else if (event.request.type === 'SessionEndedRequest') {
            callback(null, buildResponse('Session Ended'));
        }
    } catch (e) {
        context.fail(`Exception: ${e}`);
    }
};

function buildResponse(response) {
    return {
        version: '1.0',
        response: {
            outputSpeech: {
                type: 'PlainText',
                text: response,
            },
            shouldEndSession: true,
        },
        sessionAttributes: {},
    };
}

let api_key = process.env.API_PERSONAL_KEY;
let app_slug = process.env.APP_SLUG;

function buildBitriseApp(callback) {
var options = {
  'method': 'POST',
  'url': 'https://api.bitrise.io/v0.1/apps/'+app_slug+'/builds',
  'headers': {
    'Authorization': api_key
  },
  body: JSON.stringify({
    "User-Agent": "alexa-skill",
    "hook_info": {
      "type": "bitrise"
    },
    "build_params": {
      "branch": 'main',
      "workflow_id": 'primary'
    }
  })
};
    request.post(options, function(error, response, body){
        if(error){
            callback("ERROR");

        } else {
            callback(null,"SUCCESS");
        }
    });
}

In the above code, we are specifying that when we launch the skill we’ll receive a message “Hello from Bitrise” and check if the intentName is “triggerBuild”.

We can call the function “buildResponse”, which calls the POST endpoint from Bitrise API with the payload that we added, specifying the following parameters:

API Key
App Slug
Branch Name
Workflow ID

And we already added the API Key and the App Slug as Lambda Environment Variables.

Click the Deploy button to save the changes.

Now it’s time to add the Alexa Skill Kit as a trigger for our Lambda function.

Click on the + Add trigger button in the Function Overview and the trigger configuration and select the Alexa Skills kit.

Then you can add your Skill ID and click the add button. You can get the Skill ID from the Endpoint menu in the Skill Kit build section.

And now the trigger should be displayed like this:

On the other side, you need to add the Lambda ARN from the Lambda function page.

And go to the Alexa Skill kit by opening the Endpoint option in the build section and pasting the ARN there, then clicking Save Endpoint and choosing yes.

After that, click on the Code button and you will see a notification that the default endpoint has changed and is no longer hosted by Alexa because it’s now on AWS and Lambda.

Test the integration between Lambda and Alexa

Now click on the Test button to go to the Alexa Simulator page. And in the development write the following phrase:

“Alexa, open bitrise ci” and click the Enter button

To trigger a new build you can write: “Alexa, ask bitrise ci trigger a new bitrise build” and click the Enter button

Open your Bitrise Dashboard and, if the command ran successfully, you will notice that the build was triggered successfully and you can abort it after that to save your credits.

We did it! Congratulations you have successfully triggered your first build using Bitrise API, Lambda via Alexa Skill kit.

Amazing!

Specifying the git branch name and the workflow name using Slots

You may notice that in our Lambda function we are using hardcoded values like the branch name and the workflow name as build parameters.

"build_params": {
      "branch": 'main',
      "workflow_id": 'primary'
    }

But what if I need to use different values... Can I do that?

Of course, you can!

In the first part, we mentioned that Alexa Skill has a key feature which is Slots and you can use them as variables that you provide with a name and a slot type for each slot in your interaction model.

Let’s do it then!

In your Alexa Skills Console, click on Build then click on Slot Types, and click Add Slot Type.

Add BranchName and click the Next button
Enter default values such as main and master

Add another Slot WorkflowName click the Next button
Enter default values such as deploy and primary

Click on Intents then triggerBuild intent
Change the Sample Utterance to be like the following:

The Slots will be added under Intent Slots and make sure that the Slot Type is what we created previously.

var request = require('request');

var workflowSlot;
var branchSlot;

exports.handler = (event, context, callback) => {

    try {
        if (event.request.type === 'LaunchRequest') {
            callback(null, buildResponse('Hello from Bitrise'));
        } else if (event.request.type === 'IntentRequest') {
            const intentName = event.request.intent.name;
            workflowSlot = event.request.intent.slots.WorkflowName.value;
            branchSlot = event.request.intent.slots.BranchName.value;

            if (intentName === 'triggerBuild') {

                buildBitriseApp(function (err, result) {
                    if(!err) callback(null, buildResponse('The build was launched with '+ workflowSlot +' workflow for '+ branchSlot + ' branch. make sure you take a look.'));
                    else callback(null, buildResponse("Please check your build logs. Something went wrong."));
                });
            } else {
                callback(null, buildResponse("Sorry, i don't understand"));
            }
        } else if (event.request.type === 'SessionEndedRequest') {
            callback(null, buildResponse('Session Ended'));
        }
    } catch (e) {
        context.fail(`Exception: ${e}`);
    }
};

function buildResponse(response) {
    return {
        version: '1.0',
        response: {
            outputSpeech: {
                type: 'PlainText',
                text: response,
            },
            shouldEndSession: true,
        },
        sessionAttributes: {},
    };
}

let api_key = process.env.API_PERSONAL_KEY;
let app_slug = process.env.APP_SLUG;

function buildBitriseApp(callback) {
var options = {
  'method': 'POST',
  'url': 'https://api.bitrise.io/v0.1/apps/'+app_slug+'/builds',
  'headers': {
    'Authorization': api_key
  },
  body: JSON.stringify({
    "User-Agent": "alexa-skill",
    "hook_info": {
      "type": "bitrise"
    },
    "build_params": {
      "branch": branchSlot,
      "workflow_id": workflowSlot
    }
  })
};
    request.post(options, function(error, response, body){
        if(error){
            callback("ERROR");

        } else {
            callback(null,"SUCCESS");
        }
    });
}

In the above code we added these values:

var workflowSlot;
var branchSlot;

workflowSlot = event.request.intent.slots.WorkflowName.value;
branchSlot = event.request.intent.slots.BranchName.value;

And in the build parameters we replace the hardcoded values: 
"build_params": {
      "branch": branchSlot,
      "workflow_id": workflowSlot
    }

Click Deploy to save the changes and now you can test your Alexa Skills Kit.

In the Alexa Simulator write the following phrase:

“Alexa, ask bitrise ci trigger build for primary workflow for main branch”

Note: You should have a workflow and branch name with the same values otherwise the build will not be triggered

I will try to use different apps and specify the workflow name and the branch name as well.

Monitor AWS Lambda with CloudWatch

You can also check the runtime metrics for your functions on Amazon CloudWatch. The metrics shown are an aggregate view of all function runtime activity.

What’s next?

In the next article, we will distribute our Alexa Skills Kit to be able to use in our AWS organization.