DEV Community: beretests

Perfect Landing: Goat Cheese Day

beretests — Sat, 28 Jun 2025 15:59:02 +0000

This is a submission for Frontend Challenge - June Celebrations, Perfect Landing: June Celebrations

What I Built

I built a landing page to celebrate Goat Cheese Day (June 25). The goal was to highlight the joy, diversity, and community around goat cheese. The page features a modern, responsive design built with React and Material UI. It includes sections about the origins and benefits of goat cheese, the different types, recipes and pairings, FAQs, and upcoming events. Users can sign up for a newsletter, download a recipe booklet, and explore interactive content — all designed to promote and celebrate Goat Cheese Day in a fun and informative way.

Demo

For a limited time, this landing page can be viewed live at Goat Cheese Day Page. Please feel free to interact with the page and let me know what you think!

This project code can also be viewed on Github below:

beretests / devto-challenge-june-celebrations-2025

DevTo Challenge: June Celebrations 2025 (Goat Cheese Day) – Vite + React + Material UI + Tailwind CSS

Celebrate Goat Cheese Day with this interactive, modern web app built using Vite, React, Material UI, Tailwind CSS, and Zustand.

Features

Responsive design with Material UI and Tailwind CSS
Light, dark, and system theme support
Interactive sections: About, Benefits, Types, Recipes, FAQs, Events, and more
Newsletter signup and event sidebar
Downloadable recipe booklet (demo)
Animated transitions and snackbars
State management with Zustand

Getting Started

Prerequisites

Node.js (v18+ recommended)
npm or yarn

Installation

Clone the repository and install dependencies:

git clone https://github.com/your-username/goat-cheese-app.git
cd goat-cheese-app
npm install

Development

Start the development server:

npm run dev

Open http://localhost:5173 in your browser.

Build

To build for production:

npm run build

To preview the production build:

npm run preview

Project Structure

src/ – Main source code (components, theme, stores, assets)
public/ –…

View on GitHub

Journey

First off, I'd like to say a huge THANK YOU to the dev.to team for putting this challenge together. When designing web pages, I tend to think more in terms of functionality than aesthetics so this was a great chance to flex my design skills 😉

Landing page was built with React, Typescript, Vite and MUI. I originally planned to also use Taiwind for styling but I did a deep dive into the MUI Component APIs and found it much easier to do the component styling with those instead. I originally set up the project with MUI's Vite example with Tailwind CSS in TypeScript. I started by planning the sections and user flow, then built reusable components for each feature (like FAQs, recipes, and events).

Learning Takeaways

Create and apply custom themes using the MUI theme builder. One of the hardest things for me in web design is picking a color (or font) so this was really helpful.
Separation of concerns: I tried to separate 'data' from code where possible as can be observed in the components directory. I think it helps to make the code more readable.
Use of Zustand for simple state management. Switching between themes is now a breeze and I am able to add as many themes as I want (pretty cool). It also facilitated the implementation of alerts (on newsletter subscription and recipe download) making the landing page very interactive.
Use of Zustand stores to implement alerts using MUI snackbar. This will help make the code more extensible if more features that require in-app alerts are added.

Proud Moments

I'm especially proud of the interactive animations (like the animated events and animated list of benefits of goat cheese) which I implemented using the Framer Motion library. I'm also proud of the theme switcher implemented with MUI theming.

Next Steps

I'd like to dive deeper into the following:

more event interactivity
improving accessibility
adding tests to ensure maintainability of the code

Understanding Stock Trends: Insights from 10 Years of Data

beretests — Tue, 04 Feb 2025 10:57:36 +0000

I've always entertained the idea of actively investing in stocks (especially when I hear news of significant growth in the investments of big players after major world events). I find it overwhelming though, especially with so many companies to choose from and factors to consider before selecting stocks to invest in.

I recently started doing some Data Analytics, Machine Learning and AI courses as part of the M2M DataTalent program. For my first capstone project, I analysed ten years (2012 - 2022) of daily stock data for major social media companies (Facebook (Meta), Twitter, Snapchat, Etsy, and Pinterest) to uncover valuable insights.

Data Source: Kaggle

Key Findings from the Analysis

1. Price Trends Over Time

I tracked the adjusted closing prices of these stocks over the period using a comparative line chart. This visualized how the value of each stock evolved and highlighted significant moments of growth or decline.

Relevance: This shows which stocks have shown consistent growth and which have faced major challenges, useful information for investors to understand long-term stability.

2. Trading Volume Analysis

I compared the trading volumes across stocks using stacked bar charts. Volume measures how actively a stock is being bought and sold — a key indicator of market interest.

Relevance: High trading volumes may indicate investor confidence (or sometimes lack thereof) or reactions to major news, while low volumes could signal lack of interest or stability.

3. Correlation Between Stocks

A correlation heatmap revealed how closely the stocks move in relation to each other which was to be expected given that they are all in the same market.

Out of curiosity, I decided to also compare these stocks to a completely different investment (in this case, Gold) to observe their correlation. As expected, the correlation between gold and the other stocks though negative, was barely existent.

Gold Data Source: Kaggle
Relevance: Understanding these relationships would help investors diversify portfolios to manage risk better.

4. Daily Returns and Volatility

I analyzed the daily returns, which is simply how much a stock’s price changes day to day, and mapped their distributions.

This helped to assess:

Average returns (potential gains).
Variability (volatility or risk).
Extreme values (outliers that may indicate unusual events).

Relevance: This gives a clear picture of what to expect from a stock — steady growth or erratic swings between growth and decline.

5. Cumulative Returns

Analysis of the stock cumulative returns is relevant to show the total growth of the stock investments over time. This provides a long-term perspective.

Relevance: From the chart above, one can easily infer which stocks would have provided the best returns for investors who held their stocks for years.

Conclusion

The stock market is very complex, especially for novice investors like me. I now understand however (and I hope you do too), that with the right tools and insights, it becomes easier to navigate. By analyzing historical data and focusing on important metrics like price trends, volumes, and returns, one can start building a solid foundation in stock investment.

Addendum: The Tools Behind the Analysis

To perform this analysis, I used a range of data science tools and techniques. Here are the tools used:

Python: The programming language used for data cleaning, processing, and visualization.
NumPy: For handling numerical data and performing mathematical calculations.
Pandas: A Python library that makes it easy to manipulate and analyze large datasets.
Bokeh: Visualization tool used to create charts.
Jupyter Notebooks: An interactive coding environment where the analysis was conducted and documented. The code used in this analysis can be viewed in this notebook.

Running a Discord Bot on Raspberry Pi

beretests — Tue, 01 Oct 2024 02:43:59 +0000

Cover Photo by Daniel Tafjord on Unsplash

I recently completed a software engineering bootcamp, started working on LeetCode easy questions and felt it would help keep me accountable if I had a daily reminder to solve questions. I decided to implement this using a discord bot running on a 24 hour schedule (on my trusty raspberry pi, of course) which would do the following:

go to a predefined databank of easy leetcode questions
grab a question which has not been posted to the discord channel
post the leetcode question as a thread in the discord channel (so you can easily add your solution)
question is marked as posted to avoid posting it to the channel again

I realize it may be easier to just go to LeetCode and solve a question a day but I got to learn a lot about Python and Discord with help from ChatGPT on this mini-project. This is also my first attempt at sketchnoting so please bear with lol

Setup

1. Use python virtual environment
2. Install dependencies
3. Set up Leetcode easy questions database
4. Set up environment variables
5. Create Discord app
6. Run the Bot!

1. Use python virtual environment

I recommend the use of a python virtual environment because when I initially tested this on Ubuntu 24.04, I encountered the error below

Setting it up is relatively easy, just run the following commands and voila, you're in a python virtual environment!

python3 -m venv ~/py_envs
ls ~/py_envs  # to confirm the environment was created
source ~/py_envs/bin/activate

2. Install dependencies

The following dependencies are required:

AWS CLI

Install AWS CLI by running the following:

curl -O 'https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip'
unzip awscli-exe-linux-aarch64.zip 
sudo ./aws/install
aws --version

Then run aws configure to add the required credentials. See Configure the AWS CLI doc.

pip dependencies

The following pip dependencies can be installed with a requirements file by running pip install -r requirements.txt.

# requirements.txt

discord.py
# must install this version of numpy to prevent conflict with
# pandas, both of which are required by leetscrape
numpy==1.26.4   
leetscrape
python-dotenv

3. Set up leetcode easy questions database

Leetscrape was vital for this step. To learn more about it, see the Leetscrape docs.
I only want to work on leetcode easy questions (to me, they're even quite difficult) so I did the following:

grab the list of all questions from leetcode using leetscrape and save list to csv

from leetscrape import GetQuestionsList

ls = GetQuestionsList()
ls.scrape() # Scrape the list of questions
ls.questions.head() # Get the list of questions
ls.to_csv(directory="path/to/csv/file")

create an Amazon DynamoDB table and populate it with list of easy questions filtered from csv saved in previous step.

import csv
import boto3
from botocore.exceptions import BotoCoreError, ClientError

# Initialize the DynamoDB client
dynamodb = boto3.resource('dynamodb')

def filter_and_format_csv_for_dynamodb(input_csv):
    result = []

    with open(input_csv, mode='r') as file:
        csv_reader = csv.DictReader(file)

        for row in csv_reader:
            # Filter based on difficulty and paidOnly fields
            if row['difficulty'] == 'Easy' and row['paidOnly'] == 'False':
                item = {
                    'QID': {'N': str(row['QID'])},  
                    'titleSlug': {'S': row['titleSlug']}, 
                    'topicTags': {'S': row['topicTags']},  
                    'categorySlug': {'S': row['categorySlug']},  
                    'posted': {'BOOL': False}  
                }
                result.append(item)

    return result

def upload_to_dynamodb(items, table_name):
    table = dynamodb.Table(table_name)

    try:
        with table.batch_writer() as batch:
            for item in items:
                batch.put_item(Item={
                    'QID': int(item['QID']['N']),  
                    'titleSlug': item['titleSlug']['S'],
                    'topicTags': item['topicTags']['S'],
                    'categorySlug': item['categorySlug']['S'],
                    'posted': item['posted']['BOOL']
                })
        print(f"Data uploaded successfully to {table_name}")

    except (BotoCoreError, ClientError) as error:
        print(f"Error uploading data to DynamoDB: {error}")

def create_table():
    try:
        table = dynamodb.create_table(
            TableName='leetcode-easy-qs',
            KeySchema=[
                {
                    'AttributeName': 'QID',
                    'KeyType': 'HASH'  # Partition key
                }
            ],
            AttributeDefinitions=[
                {
                    'AttributeName': 'QID',
                    'AttributeType': 'N'  # Number type
                }
            ],
            ProvisionedThroughput={
                'ReadCapacityUnits': 5,
                'WriteCapacityUnits': 5
            }
        )

        # Wait until the table exists
        table.meta.client.get_waiter('table_exists').wait(TableName='leetcode-easy-qs')
        print(f"Table {table.table_name} created successfully!")

    except Exception as e:
        print(f"Error creating table: {e}")

# Call function to create the table
create_table()

# Example usage
input_csv = 'getql.pyquestions.csv'  # Your input CSV file
table_name = 'leetcode-easy-qs'      # DynamoDB table name

# Step 1: Filter and format the CSV data
questions = filter_and_format_csv_for_dynamodb(input_csv)

# Step 2: Upload data to DynamoDB
upload_to_dynamodb(questions, table_name)

4. Set up environment variables

Create a .env file to store environment variables

DISCORD_BOT_TOKEN=*****

5. Create Discord app

Follow the instructions in the Discord Developer docs to create a Discord app and bot with adequate permissions. Be sure to authorize the bot with at least the following OAuth permissions:

Send Messages
Create Public Threads
Send Messages in Threads

6. Run the Bot!

Below is the code for the bot which can be run with the python3 discord-leetcode-qs.py command.

import os
import discord
import boto3
from leetscrape import GetQuestion
from discord.ext import tasks
from dotenv import load_dotenv
import re
load_dotenv()

# Discord bot token
TOKEN = os.getenv('DISCORD_TOKEN')

# Set the intents for the bot
intents = discord.Intents.default()
intents.message_content = True # Ensure the bot can read messages

# Initialize the bot
bot = discord.Client(intents=intents)
# DynamoDB setup
dynamodb = boto3.client('dynamodb')

TABLE_NAME = 'leetcode-easy-qs'
CHANNEL_ID = 1211111111111111111  # Replace with the actual channel ID

# Function to get the first unposted item from DynamoDB
def get_unposted_item():
    response = dynamodb.scan(
        TableName=TABLE_NAME,
        FilterExpression='posted = :val',
        ExpressionAttributeValues={':val': {'BOOL': False}},
    )
    items = response.get('Items', [])
    if items:
        return items[0]
    return None

# Function to mark the item as posted in DynamoDB
def mark_as_posted(qid):
    dynamodb.update_item(
        TableName=TABLE_NAME,
        Key={'QID': {'N': str(qid)}},
        UpdateExpression='SET posted = :val',
        ExpressionAttributeValues={':val': {'BOOL': True}}
    )

MAX_MESSAGE_LENGTH = 2000
AUTO_ARCHIVE_DURATION = 2880

# Function to split a question into words by spaces or newlines
def split_question(question, max_length):
    parts = []
    while len(question) > max_length:
        split_at = question.rfind(' ', 0, max_length)
        if split_at == -1:
            split_at = question.rfind('\n', 0, max_length)
        if split_at == -1:
            split_at = max_length

        parts.append(question[:split_at].strip())
        # Continue with the remaining text
        question = question[split_at:].strip()

    if question:
        parts.append(question)

    return parts

def clean_question(question):
    first_line, _, remaining_question = message.partition('\n')
    return re.sub(r'\n{3,}', '\n', remaining_question)

def extract_first_line(question):
    lines = question.splitlines()
    return lines[0] if lines else ""

# Task that runs on a schedule
@tasks.loop(minutes=1440) 
async def scheduled_task():
    channel = bot.get_channel(CHANNEL_ID)
    item = get_unposted_item()

    if item:
        title_slug = item['titleSlug']['S']
        qid = item['QID']['N']
        question = "%s" % (GetQuestion(titleSlug=title_slug).scrape())

        first_line = extract_first_line(question)
        cleaned_question = clean_message(question)
        parts = split_message(cleaned_question, MAX_MESSAGE_LENGTH)

        thread = await channel.create_thread(
            name=first_line, 
            type=discord.ChannelType.public_thread
        )

        for part in parts:
            await thread.send(part)

        mark_as_posted(qid)
    else:
        print("No unposted items found.")

@bot.event
async def on_ready():
    print(f'{bot.user} has connected to Discord!')
    scheduled_task.start()

@bot.event
async def on_thread_create(thread):
    await thread.send("\nYour challenge starts here! Good Luck!")

# Run the bot
bot.run(TOKEN)

There are multiple options to run the bot. Right now, I'm just running this in a tmux shell but you could also run this in a docker container or on a VPC from AWS, Azure, DigitalOcean or other cloud providers.

Now I just have to actually attempt solving the Leetcode questions...

Setting up a Gitlab Server on a Raspberry Pi 4

beretests — Mon, 22 Apr 2024 23:05:41 +0000

Preamble

My initial plan was to set up the GitLab server in docker on the Raspberry Pi mainly for portability as I would be setting up different tools and had no plans to add resources to the Pi. However, I ran into some problems. I'm not particularly equipped to resolve them now (believe me I tried) but I intend to retry this sometime in the future. Perhaps some of those issues would be resolved by then (such as an available GitLab docker image that runs on Pi 4 on 32-bit Debian/buster).

Please read my initial post to understand why I chose Raspberry Pi as the server host.

Setup Steps

The steps to complete the setup are outlined below. Expand each step (by clicking on it) for details.

Install screenshot on the Pi
I needed a way to take screenshots on the Pi to record the actions to complete the setup. I found the recommendations on this page helpful. I went with installing Gnome Screenshot. It's not as intuitive as simply tapping Cmd + Shift +4 on a Mac but it does the job.

Network Setup
I'm on a standard home network with a simple router and the connecting devices - the Pi, a few laptops a TV, etc (you get the drift). The router assigns IP addresses to the devices via DHCP. All devices on the network have the same public IP address so I had to ensure that all requests to the GitLab server would go to the Pi. I'll outline the steps taken to achieve this.

DISCLAIMER: This was a bit of head-scratcher for me given I'm no networking guru. It was a huge relief when I finally got it working. I also got to enhance my understanding of how networks work so yay!

Edit DNS configuration on the router

Given that the public IP address assigned by the router was not static, I needed to mitigate the issue of loss in connectivity to the server if/when it changed. Luckily, DNS for my hosts is managed in Cloudflare and they have a few options for this.
I chose to use DNS-O-Matic by going to the link from the Cloudflare page linked above and following the subsequent setup instructions.

Set the private IP address on the Pi to static

The IP addresses assigned to the devices by the routers have set lease periods so the Raspberry Pi's IP address would change at given intervals. This was not ideal for my desired setup because I needed a stable way to direct traffic to it (the Pi). This was easily resolved by setting the private IP address to fixed or static in the router so that it never changes. Different routers have different ways to do this so I'll not provide details.

Enable port forwarding on the router

(Welcome to the most head-scratchy part of this!)
By default, the router is set up to block all incoming connections to the devices. It was necessary to enable port forwarding from the router to the Pi. In summary, this is opening one or two ports (I opened 2) on the router and directing all connections from that port to a port on the Pi. The exact way to do this varies from router to router so I won't get into detailed steps here but I found the following links useful (they are a little old but still useful, I found):

https://www.computerhope.com/issues/ch001201.htm
https://nordvpn.com/blog/open-ports-on-router/

Install gitlab server accessible on HTTP
In the previous step, I did not open the standard ports 80 and 443 for HTTP and HTTPs because I still plan to install other services accessible on the web. This Wikipedia article has a list of available ports - in total, there are 65,535. In addition (and I could be wrong here), using a different port provides an additional layer of security since bad actors typically send bad requests to known ports.

FUN FACT: I once worked with an older engineer who was often miffed at how unimaginative the requests sent by bad actors were. He would be even more upset that those requests were sometimes successful implying that sysadmins were not doing enough to mitigate known vulnerabilities. I enjoyed working with him and learned a lot from him.

To install the GitLab server, I followed the steps outlined in the GitLab installation guide for the Raspberry Pi (thanks, GitLab for the easy-to-follow instructions). I skipped the step to install postfix since I already had an account with Zoho mail.

On the first few tries of running the installation, it failed because LetsEncrypt, which is enabled by default, could not create the required TLS certificates to run on HTTPS as I had set the EXTERNAL_URL similar to https.gitlab.<site-name>.com.

This is when I decided to set the server as accessible on HTTP. The SSL configuration was then completed in the next step.
Given the number of installs I ran, I created a simple bash script for subsequent reruns instead of entering single commands multiple times.



#!/bin/bash

# Install and configure the necessary dependencies
sudo apt-get install curl openssh-server ca-certificates apt-transport-https perl
curl https://packages.gitlab.com/gpg.key | sudo tee /etc/apt/trusted.gpg.d/gitlab.asc

# Add the GitLab package repository
sudo curl -sS https://packages.gitlab.com/install/repositories/gitlab/raspberry-pi2/script.deb.sh | sudo bash

#  install the GitLab package
sudo EXTERNAL_URL="http://gitlab.<site-name>.com:<port-number>" apt-get install gitlab-ce

I then made the file executable by running sudo chmod +x filename.

The GitLab server was then successfully installed (finally!) with the following displayed:

A quick visit to the URL confirmed this and I could log in with the root password located at /etc/gitlab/initial-root-password, and change that password via the provided instructions.

Setup acme-dns-certbot to run the server on HTTPS
To enable HTTPS and avoid opening port 80 to allow LetsEncrypt to create the required certificates, I opted to set LetsEncrypt to use the dns-challenge type as opposed to the http-challenge commonly used (more details on challenge types).

I'm using Cloudflare to manage DNS and LetsEncrypt has detailed instructions on how to set this up so I won't go into details on how I did this but I'll add the links:

On completion of this setup and getting the certificates for my site, I then changed the following in the config file located at /etc/gitlab/gitlab.rb



nginx['ssl_certificate'] = "<path-to-fullchain-cert>"
nginx['ssl_certificate_key'] = "<path-to-key>"
nginx['redirect_http_to_https'] = true
external_url = "https:gitlab.<site-name>.com:<port-number>"
letsencrypt['enable'] = false

I then ran sudo gitlab-ctl reconfigure.

The server was then available at the new HTTPS URL (I had to wait a few minutes after the command run completed) which I confirmed in the screenshot below. Root login also worked as before.

Change SMTP Settings
This initial setup's final step was configuring SMTP since I skipped the postfix install step during installation. As usual, the documentation provides handy examples for this so I just changed the settings in /etc/gitlab/gitlab.rb following the Zoho example in the docs and ran sudo gitlab-ctl reconfigure again.

Next Steps

There are several ways to configure the GitLab server as can be observed in the config template. For the next step, I plan to configure it to store objects and uploads in Cloudflare's R2 (S3-compatible) storage which is currently free for up to 10G/month (please Cloudflare, don't make us start paying for this!). After that, who knows? I'll take each day as it comes and ensure I document the config changes as I go along.

Other Takeaways

I found it was necessary to uninstall the GitLab server between installation failure attempts. I found helpful instructions which I put in a simple (and eventually executable) script.



#!/bin/bash

# uninstall from gitlab-ctl
sudo gitlab-ctl uninstall
sudo gitlab-ctl cleanse
sudo gitlab-ctl remove-accounts

# uninstall with package manager 
sudo dpkg -P gitlab-ce

# delete associated directories and files
sudo rm -rf /opt/gitlab*
sudo rm -rf /var/opt/gitlab*
sudo rm -rf /etc/gitlab*
sudo rm -rf /var/log/gitlab*

# remove the entries from your apt sources
sudo rm /etc/apt/sources.list.d/runner_gitlab-runner.list*
sudo rm /etc/apt/sources.list.d/gitlab_gitlab-ee.list*
sudo rm /etc/apt/sources.list.d/gitlab_gitlab-ce.list*

In the course of uninstalling Gitlab, I encountered some issues with removing some apt repos but this StackOverflow answer helped me resolve that.

I hope you find this useful. Feel free to leave a comment to let me know your thoughts, thanks for reading!

The Start of my Devops Personal Projects Journey

beretests — Mon, 22 Apr 2024 23:04:19 +0000

Why am I doing this?

I am a software tester - have been one for more than 3 years. Before that, I'd worked in IT support for several years. I started helping out with some DevOps tasks at work over a year ago when the main DevOps guy in our team quit. I have since discovered that I enjoy the challenge of working in DevOps, especially because I am constantly learning new things.

Anyway, I decided to do some personal projects to improve my knowledge. Cue the CloudResumeChallenge which I think is one of the best things that could have happened to me (and the DevOps learning community at large). The challenge is well thought out and encompasses all the different aspects of DevOps, in my opinion.

I started the challenge, got distracted with work and life stuff, and quit after about a month. I picked up the k8schallenge when it started in March 2024 but got distracted from that as well, (I promise I don't have attention difficulties, at least I don't think so).

Anyway, I started thinking, that instead of doing such challenges, I could just document little things I do at work and in hobby projects that are related to DevOps, similar to collecting fieldstones as described by Gerald Weinberg in his book - Weinberg on Writing: The Fieldstone Method. It could simply be that I had been overwhelmed. That led me here. I haven't given up on either of the challenges yet - I'm just taking the longer route to complete them (at least that's what I tell myself hehe).

In the course of completing the cloud resume challenge, I received a $200 free credit to use with Azure as a new subscriber and let that lapse because...well, life. I did the same with DigitalOcean so when I decided to get back to it, I thought, do I have to pay to use these services now? I didn't want to (and didn't think I could even afford to, not in the long run) so I decided to start doing something (anything) on my PC.

I then remembered that, in my first year with my previous company, I had received a Raspberry Pi 4 (I may not remember exactly how I got it but I know it was from the company, I still have the package addressed to the former CEO lol - it was likely a Christmas gift or a prize for winning a game). When I got it initially, I didn't know what to do with it (I was still working at the Service Desk at the time with little knowledge of software development) so I tried to use it to teach my kids about computers with some raspberry projects. It was fun at first but their interest quickly fizzled out (they blame my teaching skills, the little buggers). So the Raspberry Pi went into a box for the next few years.

Cue the lightbulb moment! I could use the Raspberry Pi as a server for pretty much anything. I learned that in the course of completing my DevOps tasks at work. I didn't need Azure, DigitalOcean, or any other cloud providers, not for my immediate needs. It was a personal project, I didn't need to pay anything. I could set up applications of all kinds, the world was my oyster, oh the joy!

So that's how I came to be writing this! It's mostly a way to track my progress and stay accountable. I'll start with setting up a Gitlab server on the Raspberry Pi because I want to set up pipelines for other tasks - just one of the things I haven't gotten to do at work yet. Hopefully, I'll get ideas for other tasks as I go along.

Cover Photo by Katerina Holmes: https://www.pexels.com/photo/crop-black-woman-taking-notes-from-laptop-5905852/