Role Description

This is a role description

Key Responsibilities

In fulfilling the role of <Role> , you will be responsible for:

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

Helpful Resources

• Resource

Role Description

This is a role description

Key Responsibilities

In fulfilling the role of <Role> , you will be responsible for:

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

Helpful Resources

Role Description

This is a role description

Key Responsibilities

In fulfilling the role of <Role> , you will be responsible for:

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

Helpful Resources

• Review & Watch

  • Read The Definitive Guide for Team Members

  • Review your relevant Roles & Responsibilities

• Join Our Discord

  • Accept Invitation

  • Introduce yourself in our ‘Introductions’ Channel! We want to know more about you!

  Please ensure your profile picture is NOT the default discord picture

• Accept our Github Invitation

  • Please create/Log into your GitHub. You will also be using GitHub projects.

• Role-specific Expectations

  • Be sure to discuss the expectations of your role with your team lead.

• SMART Goals

  • Open the SMART Goals Template

  • Select ‘file’->’make a copy’.

  • Add your SMART Goals to your copy

  This will ensure your team lead will be able to coach you to achieve your SMART goal throughout your time here at Dev Launchers!

• Google Calendar & Shared Folder

  • Access our Google Calendar & Shared Folder

Role Description

This is a role description

Key Responsibilities

In fulfilling the role of <Role> , you will be responsible for:

• Project Management: Guide the team through project planning, setting priorities, and ensuring timely delivery of milestones.

• Technical Leadership: Provide technical direction, resolve technical challenges, and ensure best practices are followed.

• Mentorship: Support team members through coaching, skill development, and performance feedback.

• Collaboration: Act as a liaison between different departments or teams, facilitating effective communication.

• Code Review: Oversee code quality by conducting regular code reviews and ensuring adherence to standards.

• Problem Solving: Identify and solve technical issues efficiently to maintain project momentum.

• Innovation: Encourage and facilitate the adoption of new technologies and methodologies to improve product quality.

• Documentation: Ensure all code and processes are well-documented for future reference and onboarding.

Helpful Resources

• Resource

Role Description

The role requires a balance between strategic thinking and detail-oriented execution to deliver a product that meets both customer needs and business objectives.

This is a role description

Key Responsibilities

In fulfilling the role of a Software Product Owner, you will be responsible for:

• Backlog Refinement: Regularly refining and updating the product backlog to keep it relevant and reflective of current priorities.

• Sprint Management: Actively participating in sprint planning meetings to ensure the development team understands the scope and priority of tasks.

• Feedback Incorporation: Gathering and incorporating feedback from users, stakeholders, and the development team to improve the product.

• Risk Management: Identifying potential risks in the product development process and developing strategies to mitigate them.

• Quality Assurance: Working closely with QA teams to ensure that the final product meets quality standards and user expectations.

• Training and Support: Providing training and support to users and stakeholders on new product features and enhancements.

Helpful Resources

Our Research Philosophy

At Dev Launchers, our research philosophy is built on a user-centric, data-driven approach. We prioritize understanding the needs and behaviors of our users, ensuring that all decisions align with enhancing user experiences. Our research is grounded in data, utilizing analytics and feedback to drive informed decisions. Collaboration is key, as we work closely with design, development, and product teams to ensure comprehensive insights. Lastly, we believe in continuous learning, constantly evolving our methodologies to adapt to industry changes and better serve our users.

Role Pages

Role Description

This is a role description

Key Responsibilities

In fulfilling the role of Product Manager, you will be responsible for:

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

Helpful Resources

Role Description

This is a role description

Key Responsibilities

In fulfilling the role of <Role> , you will be responsible for:

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

• Responsibility: Description of Responsibility

Helpful Resources

2. Meet the Team

1. Set Up Your Accounts

   • Set Up Your Figma Account Access shared design files and start collaborating with the design team.

   • Activate Your Gmail Account Log in to your new email address to stay in sync with internal communications.

   • GitHub Access Request and confirm access to the research repository and other shared resources.

   • EnjoyHQ Account Set up your login for research repository access and usability testing tools.

   • Logins for TL;DV Account Ensure you have access to TL;DV for meeting summaries and easy review.

   • Access to Hotjar & Google Analytics Get familiar with our data analysis tools for behavioral insights.

2. Familiarize Yourself with Core Tools

• Review Documentation Read through Dev Launchers’ research methodology and past project reports.

• Check Research Workflow Tools Explore UX Research project board on Github for task tracking.

• Join UX Research group on Discord Make sure you’re connected to the appropriate teams on Discord for smooth communication.

1. Meet Key Team Members

• Introduce Yourself to the Research Team Join the UX Researcher Discord channel and introduce yourself to your teammates. Share a little about your background and what you're excited to work on with the team.

• Schedule a 1:1 with Your Team Lead

  Set up a meeting with your team lead to discuss team dynamics, review SMART goals, and clarify expectations for your role.

• Join Your First UX Researcher Meeting

  Be present for the regular team standup to stay in the loop with ongoing work and team initiatives.

• Connect with the Universal Design Team Join one of the weekly meetings with the Universal Design Team to learn about ongoing projects and how research supports the design and product development process.

• Join a monthly Sprint Review Participate in the monthly Sprint Review to understand project progress, challenges, and future goals.

1. Explore Our Knowledge Base

• Review the Research GitBook Familiarize yourself with all the available resources for conducting research at Dev Launchers.

• Check Past Research Projects Browse through case studies, reports, and previous research projects for reference.

Tools:

Figma - Brainstorming

Miro - Workspaces

FigJam

**link to recruitment sheet

Overview

This guide is to help UX Researchers conduct usability tests on mobile devices.

Video Walkthrough

7MBUsablity_Testing_Mobile.mp4

Steps

How We Do Research

At Dev Launchers, we prioritize actionable insights, accessibility, and a spirit of curiosity in every step of our research process. We value user feedback and combine qualitative and quantitative methods to ensure inclusive, user-centric solutions. Collaboration across teams is key, as we iterate on ideas, refine strategies, and strive for impactful outcomes. New researchers are encouraged to deeply engage with users, stay curious, and embrace continuous improvement to uphold our commitment to creating accessible and meaningful designs.

The Steps of the Research Process

Our research process is structured to ensure efficiency and meaningful results:

• Planning & Strategy: Define goals, scope, and methods for a structured approach.

• Research Methods (Qualitative & Quantitative): Select techniques to gather valuable insights.

• Data Collection & Analysis: Organize and interpret data to uncover actionable findings.

• Reporting & Presenting Findings: Share results through clear, impactful presentations to inform decisions.

Dev Launchers SMART Goal Setting TEMPLATE

Name:

Current Role:

Date Drafted:

Reviewer(s):

Date Finalized:

What’s the initial goal you have in mind?

GOAL:

Expand on this goal using the SMART attributes.

Now rewrite your initial goal as a concise, defined SMART goal.

Within [Timely timeframe], I want to [Specific] because [Relevant]. To work toward this goal, I will [Achievable] with [names/training, etc] and expect [Measurables] to be a reasonable measure of my success to achieve this goal.

Track your goal progress

What are the action steps you need to take to achieve this goal? Order these by priority or by their due date.

• Action:

  ---

• Action:

  ---

• Action:

  ---

Am I on track to achieve this goal? What obstacles have come up and what support do you need?

• Obstacle:

  ---

• Support:

  ---

• Obstacle:

  ---

• Support:

  ---

• Obstacle:

  ---

• Support:

  ---

Milestones achieved. Note down every time you hit one of your measurable milestones along the way.

• Milestone 1:

  ---

• Milestone 2:

  ---

• Milestone 3:

  ---

Target date. Have you achieved your goal? Why or why not?

The infrastructure of DevLaunchers is designed to ensure scalability, efficiency, and reliability in hosting, testing, and deploying applications. By leveraging modern containerization, orchestration, and CI/CD practices, DevLaunchers maintains a robust platform for both development and production environments. This section provides a detailed breakdown of the infrastructure components, hosting setup, and CI/CD pipeline.

1. Hosting Environment

DevLaunchers leverages Azure Kubernetes Service (AKS) to host and manage its applications. The platform uses Kubernetes for container orchestration, providing a scalable and resilient infrastructure. Both staging and production environments run on the same Kubernetes cluster, but in different namespaces.

• Staging Environment with Serverless Optimization:

  • The staging environment is designed to optimize costs by leveraging Kubernetes-native serverless technology (Knative).

  • Knative enables the staging deployments to scale workloads to zero when not in use, minimizing resource consumption during idle periods.

  • The deployment is scaled up when there is a new request.

2. GitOps and Deployment Automation

DevLaunchers uses a GitOps workflow powered by FluxCD to handle deployments in both staging and production environments. This ensures that the infrastructure and application states are always consistent with the configuration defined in the Git repository. Flux deploys a few controllers in the flux-system to achieve this.

• FluxCD Workflow:

  • The image reflect controller scans Docker Hub for new docker images

  • When there is a new image, the image automation controller commits the new image version to the Git repository. For example, this commit updates the staging strapi image

  • The source controller monitors the GitHub repository for changes to manifests, configurations, or Docker image tags.

  • When changes are detected, the kustomize controller applies the new Kubernetes manifest to the relevant namespace.

  • This approach ensures declarative, version-controlled deployments with minimal manual intervention.

3. CI/CD Pipeline Overview

The CI is implemented using GitHub Actions to automate the testing and building processes. The CD pipeline is managed by FluxCD. The pipeline is broken into distinct stages to ensure code quality, efficiency, and reliability.

Pipeline Architecture

• Continuous Integration (CI):

  • Runs automated tests, including linting, unit testing, and end-to-end testing.

  • Generates Docker images for both staging and production environments.

• Continuous Delivery (CD):

  • Deploys Docker images to AKS clusters using FluxCD, ensuring that new versions are seamlessly integrated.

Key Workflows:

The frontend and backend have similar workflows. In the following example, we will reference workflows for the backend.

1. Test Workflow (test.yaml):

   • Triggered on each pull request (PR)

   • Runs automated tests on each PR to ensure code quality and prevent regressions.

   • Includes end-to-end tests using Playwright to validate application behavior.

2. Staging Image Workflow (staging-image.yaml):

   • Triggered when there is a new commit in the main branch

   • Builds and tags Docker images by the timestamp of the build (YearMonthDayHourMinute)

   • Push Docker images to Docker Hub.

3. Release Workflow (release.yaml):

   • Triggered when there is a new commit in the release branch

   • Handles semantic versioning using semantic-release.

   • Creates a new release tag

4. Production Image Workflow (production-image.yaml):

   • Triggered when there is a new release is published (by the release workflow)

   • Builds and tags Docker images by the release version

   • Push Docker images to Docker Hub

Triggering CI/CD:

We will use an example to demonstrate our CI/CD. The following happens when a PR is merged to the main branch:

1. The staging image workflow builds a new Docker image that is tagged in the format of <sha>-<timestamp>.

2. The image is pushed to DockerHub which triggers a webhook.

3. The webhook is sent to a dockerhub flux receiver. We configured the receiver to reconcile the ImageRepository resource.

4. The image reflector controller will discover a new image tag.

5. The ImagePolicy will extract the timestamp and pick the latest timestamp as the latest image.

6. The ImageUpdateAutomation writes the new tag back to the repository.

7. The repository has a webhook to notify the github receiver. The receiver reconciles the GitRepository resource.

8. The source controller pulls the latest Kubernetes manifests from the repository. It'll see the new image tag and update the deployment.

4. Monitoring and Logging

DevLaunchers uses a combination of tools to monitor application health, gather metrics, and alert the team in case of issues:

• Monitoring:

  • Prometheus: Used to collect metrics from the Strapi backend and Kubernetes clusters. The current setup generates application and system metrics but requires further development to set up dashboards and store metrics for analysis.

  • External Monitoring: The Uptime Robot platform monitors the production environment’s uptime by sending regular HTTP requests to the production endpoints.

• Alerting:

  • Alerts from Uptime Robot notify the team when the production website is down or experiencing performance issues. The backend service is also integrated into this monitoring system.

5. Storage and Data Management

The database for the DevLaunchers platform is hosted on a cloud cluster platform, providing scalable and highly available Postgres cluster. The staging and production use different databases but on the same cluster.

What is Strapi?

Strapi is a headless CMS (Content Management System) designed for flexibility and ease of use. As a headless CMS, Strapi allows developers to build and manage content while delivering it through APIs to various platforms, such as websites, mobile apps, and IoT devices.

Key benefits of using Strapi:

• API-Centric: Strapi automatically generates REST or GraphQL APIs for all content types, making it easy to integrate with any frontend.

• Customizable: Developers can extend or customize Strapi to suit specific project needs by modifying its controllers, services, or plugins.

• Ease of Management: Content editors can use Strapi's intuitive admin panel to manage and organize content efficiently without developer intervention.

At DevLaunchers, Strapi plays a crucial role in managing content and serving APIs for various applications, ensuring a seamless flow of data across environments.

Technical Overview

Strapi is built on the following core technologies:

• Framework: Node.js - a JavaScript runtime for building scalable backend applications.

• Language: JavaScript - the primary language used for development within the Strapi ecosystem.

• Database:

  • Development Environment: SQLite - a lightweight relational database used locally for ease of setup during development.

  • Production and Test Environments: PostgreSQL - a robust relational database ideal for handling large-scale production data and testing scenarios.

Project Overview

This section provides an overview of the project structure for the backend powered by Strapi. It is essential to understand the purpose and functionality of each major folder and file. This section will break down the structure into key components for better clarity.

Key Folders and Their Purposes

1. src/ This is the core directory for the backend logic and Strapi implementation. It contains all the custom configurations, APIs, components, and other Strapi-related features.

   • api/: This folder includes all the APIs that power the backend. Each sub-folder corresponds to a specific content type or feature. For example:

     • applicant/, project/, notification/, and others represent individual APIs created within Strapi.

     • Each API folder includes the following subfolders and files:

       • controllers/: Handles the logic for the specific API endpoints.

       • services/: Contains reusable business logic.

       • models/: Defines the data structure for the API.

       • routes/: Configures the available API routes for the content type.

   • components/: Houses reusable data structures or logic that can be shared across multiple APIs. For example:

     • people/, positions/, and links/ may define reusable building blocks or relationships used in content types or APIs.

   • extensions/: Contains custom extensions or plugins added to Strapi.

   • middlewares/: Holds custom middleware for handling requests and responses.

2. config/ This folder contains the configuration files for various environments (e.g., development, production). It includes the database configurations, server settings, and other environment-specific files.

   • database/ Manages database configurations and related setups. It ensures the backend can connect to and interact with the correct database based on the environment.

3. public/ Stores publicly accessible files such as uploaded assets, images, or static resources.

4. .env A key configuration file for managing sensitive environment variables such as database credentials, API keys, and Strapi configurations.

5. Dockerfile and Dockerfile.dev These files contain instructions for containerizing the application using Docker. This is helpful for ensuring consistent development and deployment environments.

Environment SetUp

Local Development Using Node.js

To set up the Strapi backend for local development with Node.js, follow these steps:

1. Node.js Version Requirement: Ensure that Node.js v20 is installed. Using the correct version is crucial for compatibility with the Strapi application.

2. Set Up a Version Manager: It is recommended to use a version manager like NVM (Node Version Manager) or NPM Version Manager (n) to manage Node.js versions easily.

   • Refer to the following guides for installation:

     • NVM Installation Guide

     • NPM Version Manager (n)

3. Install Dependencies and Initialize the Database: Run the following command from the project’s root directory to install all required dependencies and initialize the local SQLite database for development:

   Copy

   npm run init

4. Start the Development Server: Launch the local development server using:

   Copy

   npm run develop

5. Access the Strapi Admin Panel: Once the server is running, access the Strapi Admin interface by navigating to http://localhost:1337/admin in your browser. Use the following credentials to log in:

   • Email: local-admin@devlaunchers.org

   • Password: W&x5ZzOMtBCVt1YAUiuSzt~5

Using Docker

For developers who prefer a containerized setup, the backend can be run using Docker. Follow these steps:

1. Ensure Docker is Running: Make sure Docker Desktop is active or that the Docker daemon is running on your system.

2. Build the Docker Container: Navigate to the project’s root directory and build the Docker container by running:

   Copy

   make build-docker

   • This command builds the containerized environment for the Strapi backend. The process may take a few minutes, especially if it’s the first time.

3. Start the Strapi Server: After building the container, start the Strapi server using:

   Copy

   make run-docker

   • The server will automatically reload when you make changes to the project files, eliminating the need to restart the container manually.

4. Restart the Server if the Container Stops: If the Docker container goes down or needs to be restarted, run:

   Copy

   make run-docker

   • Note: Rebuilding the container (using make build-docker) is only necessary if significant changes are made to the configuration.

API Usage

Authentication

Strapi APIs are secured by default. To interact with protected routes, users or developers need to authenticate using JSON Web Tokens (JWT). Authentication tokens are generated upon successful login and are required to access most API endpoints.

• Public Endpoints: Can be accessed without authentication (if configured).

• Protected Endpoints: Require valid JWT tokens.

Login Endpoint: Use this endpoint to authenticate and obtain a JWT:

POST /api/auth/local
Content-Type: application/json
Body: 
{
  "identifier": "user@example.com",
  "password": "password123"
}

Response:

{
  "jwt": "eyJhbGciOiJIUzI1NiIsInR5...",
  "user": { ... }
}

Using REST APIs

Strapi's REST APIs allow developers to interact with content types using standard HTTP methods:

• GET: Retrieve content.

• POST: Create new entries.

• PUT: Update existing entries.

• DELETE: Remove entries.

Example REST API Endpoints:

1. Get All Entries for a Collection:

   Copy

   GET /api/{collection-name}

   Example:

   Copy

   GET /api/articles

2. Get a Single Entry by ID:

   Copy

   GET /api/{collection-name}/{id}

   Example:

   Copy

   GET /api/articles/1

3. Create a New Entry:

   Copy

   POST /api/{collection-name}
   Content-Type: application/json
   Body: 
   {
     "title": "New Article",
     "content": "This is an example."
   }

4. Update an Existing Entry:

   Copy

   PUT /api/{collection-name}/{id}
   Content-Type: application/json
   Body: 
   {
     "title": "Updated Title"
   }

5. Delete an Entry:

   Copy

   DELETE /api/{collection-name}/{id}

The Development Process at DevLaunchers outlines the standardized workflow, tools, and best practices developers follow to build, test, and deploy features or fixes on the platform. This structured approach ensures consistency, high-quality code, and efficient collaboration within the team. The process emphasizes key aspects such as local development, version control, automated testing, and code reviews, all designed to streamline development and maintain platform reliability.

1. Local Development and Testing

• Setting Up the Environment: Developers start by configuring their local environment. This includes setting up Strapi, running necessary dependencies, and initializing the local database. Tools such as Node.js, Docker, and npm commands are essential for the setup process.

• Feature Development: Each developer works on a specific feature, bug fix, or enhancement by writing code locally. This is done in alignment with the project’s requirements and acceptance criteria as defined in tickets or documentation.

• Testing Locally: Code is tested locally to ensure it works as intended and does not introduce regressions. Developers leverage tools such as Postman (for API testing), Strapi's built-in testing environment, or mock data to simulate real-world scenarios.

• Branching: Once local testing is complete, developers create a new branch in the GitHub repository to isolate their changes. The branch name should follow a predefined naming convention, such as: username/<feature-name>

2. Creating a Pull Request (PR)

• After completing their work in the branch, developers push their code to the remote GitHub repository.

• They then create a Pull Request (PR).

  • The PR title and description should include relevant details, such as the purpose of the changes, the issue or feature being addressed, and any dependencies or testing instructions.

  • The PR serves as the primary way for the team to collaborate on and discuss proposed changes before merging them into the main codebase.

3. Automated Testing

• GitHub Actions Integration: Submitting a PR triggers automated testing workflows via GitHub Actions. These workflows run predefined test suites to validate the code.

• Test Results: If the code fails any of the automated tests, the PR will be marked as failing, and the developer must fix the issues before proceeding. Only PRs with passing tests are eligible for review.

4. Code Review

• Collaborative Review: Once the automated tests pass, the PR is reviewed by both peers or team leads.

  • Reviewers examine the code for:

    • Adherence to coding standards.

    • Code readability, maintainability, and performance.

    • Proper handling of edge cases and errors.

    • Security concerns and best practices.

• Feedback and Iteration: Reviewers may provide feedback or request changes. The developer revises the code accordingly and updates the PR until all comments are resolved.

5. Merging Approved Code

• Approval and Merge: Once the code passes both automated tests and manual code reviews, it is approved for merging.

  • Developers merge the branch into the main branch (staging branch).

• Deployment to Staging: The merged code is automatically deployed to the staging environment. This allows the team to perform final testing and validation before deploying it to production in the next release.

6. Deployment to Production

• Once the code has been validated in staging, it can be deployed to the production environment. This deployment process require manual triggers by pushing the code to the release branch (production branch).

Development Environment and SVM Setup

1. Version Control

• DevLaunchers uses Git for version control, hosted on GitHub.

• Developers follow a branching strategy to manage feature development, bug fixes, and releases.

2. Environment Types

The development pipeline includes multiple environments to ensure code quality and stability:

• Local Environment: Where developers write and test code on their machines.

• Staging Environment: A replica of production used for final testing.

• Production Environment: The live application used by end-users.

3. Source Version Manager (SVM)

• GitHub is the primary SVM used to manage the source code repository.

• Developers interact with the repository using Git commands and PR workflows.