In this guide, we will discuss some best security measures for a secure Django project before your next deployment.

Let's learn!

Security Measures for Authentication and Authorization

When building a Django application, user management requires prioritizing authentication and authorization as key security measures.

Here are some security practices when working on authentication and authorization features:

1. When dealing with authenticating users, it is best to implement a secure user authentication like password-based, token-based, or multi-factor authentication. This ensures you verify your users more than once and when they want to use your application.
2. If you use a password-based authentication, ensure you are using a strong hashing algorithm like the Django's make_password function to avoid storing the password as plain text.
3. When hashing user passwords, ensure you implement salt generation. Generate a unique random data (salt) to strengthen the hashing process of the password and prevent pre-computed attacks.
4. Consider using token-based authentication and set an expiration timer to add another layer of security. This lets the user's access token expire after a certain time and they will need to verify their identify again to continue using your application. Note that when implementing this, ensure that you don't set the timer to expire every 5 minutes, 30 minutes or one hour so it doesn't negatively affect user experience.
5. When dealing with users, always implement a Role-Based Access Control (RBAC) to assign roles to each user. That is, users can only access user features and admins can access user and other extended features.
6. After hashing the password and having an access control, implement appropriate access control and encryption measures so that only authorized users can access their passwords.

Security Measures Against SQL Injection Attacks

SQL injection attacks are one of the most web vulnerabilities, and Django projects can be exploited through such attacks, especially when the data moving from client-side to server-side is vulnerable.

An excellent way for you to nip these attacks in the bud in your Django projects is to use parameterized queries. Parameterized queries are an easy way in separating the SQL code from the user input, ensuring that user data is not part of the SQL command using Django ORMs.

Here is how it works. You can directly query the data in your database like this:

from .models import User  

def user_search(request):
    username = request.GET.get('username')

    # Vulnerable query construction
    query = "SELECT * FROM users WHERE username = '" + username + "'"

    # Return a response
    return HttpResponse("User search query: " + query)

You can use the Django QuerySet filter() method to filter the data and sanitize it, like this:

from .models import User

def user_search(request):
    username = request.GET.get('username')

    # Safe query using parameterized query
    users = User.objects.filter(username=username)

    # Return a response
    return HttpResponse("User search executed securely.")

Security Measures Against Cross-Site Scripting (XSS)

Cross-site scripting or XSS attack happen by injecting malicious scripts in a web page or application accessed by other users. These attacks could be exploited in your Django projects if you forget to validate user data, prevent browsers from interpreting your web content or omit a content security policy.

Here are some security practices when avoiding XSS attacks:

Validate User Data

When dealing with user-generated data, ensure you always validate the data. You can use built-in validation tools like the [django.core.validators](https://docs.djangoproject.com/en/1.8/_modules/django/core/validators/) function.

Here is an example of validating an email address gotten from the client-side:

from django.core.validators import validate_email

email = request.GET.get('email')

if not validate_email(email):
    raise ValueError("Invalid email address.")

Here is another example of validating a URL gotten from the user:

from django.core.validators import URLValidator
from django.core.exceptions import ValidationError

def validate_url(url):
    validator = URLValidator()
    try:
        validator(url)
    except ValidationError as e:
        return e.message
    return None

Always Encode User Data When Displaying It

If your project takes user data and display it, ensure that you properly encode the data using Django auto-escaping template, {% autoescape %}. The autoescape tag is used to check if the autoescape is on or off. If it is on, it ensures the HTML code in your variables are escaped.

Here is an example:

{% autoescape on %}
    {{ user_input }}
{% endautoescape %}

Use the Correct HTTP Headers

In your Django project, always set appropriate HTTP headers to prevent browsers from interpreting the content as executable scripts. This may be minor, but it will prevent browsers from guessing the type of your response.

Here are two HTTP headers you can implement:

1. X-Content-Type-Options: This configuration ensures browsers don't sniff or guess the Multipurpose Internet Mail Extensions (MIME) type of a response. MIME is used to specify format of internet messages.
2. Content-Type: text/html: charset=UTF-8: This configuration ensures your web content is treated as a HTML and properly encoded as one.

You can define these headers in your template files to avoid XSS attacks.

Always Use Content Security Policy

Content Security Policy (CSP) is a security measure used in web browsers to prevent malicious attacks, XSS attacks and data injections. This policy lets web developers define trusted sources like images, scripts, CSS styles, and so on, on their projects.

Content Security Policies are usually delivered through HTTP headers or HTML meta tags to enhance security of your web applications.

In your Django project, you can implement CSP like this:

from django.http import HttpResponse

response = HttpResponse("Your content here")
response['Content-Security-Policy'] = "default-src 'self'; script-src 'self' https://trusted-cdn.com;"

Security Measures Against Cross-Site Request Forgery (CSRF)

Cross-Site Request Forgery (CSRF) is a vulnerability that attacks by tricking users into carrying out actions against their knowledge or consent. These attacks use a request to trick the user into submitting a link or form on a different website or web application and since the request comes from the user's authenticated session, it pulls through, and the attacker has access to either perform a data manipulation or do any unauthorized action.

To prevent such attacks in your Django project, you can implement these practices:

Use Middleware-Based Rate-Limiting

Rate-limiting is used for controlling the frequency of requests made by a server, API or user. This works by having a limit on the number of requests that can be made within a certain period of time.

In your Django project, it is good practice to create or implement a custom middleware to track and limit user's request based on a user's IP address. If you can't create a custom middleware, you can use django-rate limiting package.

Enable CSRF Middleware

Cross-Site Request Forgery (CSRF) middleware in Django is a built-in security tool that protects against CSRF attacks by validating CRSF token when making requests, such as when a user wants to log in.

It is a good idea to enable Django's CRSF middleware in your settings.py.

MIDDLEWARE = [
 ...
 'django.middleware.csrf.CsrfViewMiddleware'
 ...
]

Always Use CRSF Tokens

Cross-Site Request Forgery (CSRF) tokens are random data generated by your server and included as hidden fields in your HTML forms or added to AJAX requests.

CRSF tokens work with CRSF middleware, you can't use one without the other. When using CRSF tokens, Django automatically handles the tokens for you when you use the {% crsf token %} template tag.

<form method="post">
    {% csrf_token %}
    ...
</form>

Built-in Django Security Checklist

Not many developers know this, but Django has a built-in security checklist to ensure you deploy a tightly secured project.

It is a command that scans your settings.py and checks if you pass Django security guidelines or if you have any vulnerabilities hackers could exploit. The command is python manage.py check --deploy

When you run the command, you should see all the warnings and may see some project errors (if you have any), something like this:

Screenshot showing results of the command

Other Security Practices

In addition to security practices targeted at specific web vulnerabilities, implementing minor practices can also enhance the overall security strength of your application.

1. Implement a way to continuously monitor your deployed Django application to detect and respond to security incidents or vulnerabilities in real-time.
2. Update your Django framework, dependencies and third-party libraries every 2-4 months so your project is up to date and uses the latest security patches and is bug-free.
3. You can also implement logging to monitor and record security-related changes or activities happening in your projects. It can also take note of possible security incidents.

Conclusion

In conclusion, securing a Django application needs so much attention and a multi-layered strategy. This includes implementing secure authentication, validating user input, ensuring encrypted end-to-end communication (whether client-to-server or user-to-user), and applying rate-limiting measures.

These practices contribute to a more robust and secure project.

Among the many authentication methods available, GitHub OAuth has emerged as a useful tool for improving user login experience while strengthening security measures.

Django, a Python web framework, has recently gained popularity in web development due to its efficiency and versatility. Adding GitHub OAuth to your Django projects helps improve the authentication process.

Django developers can use GitHub OAuth to access a user's GitHub profile and (with permission) their repositories to personalize the user experience and tailor application services.

This article will walk you through how to implement GitHub OAuth. You'll see the benefits to your Django projects as we go. By embracing this technology, you can give users a seamless login experience while adhering to strict security standards.

Prerequisites

If you wish to follow this guide, you need to have a basic understanding of these tools or have them installed on your PC:

• GitHub
• Django
• Django Rest Framework

How to Create a GitHub OAuth Application

You must sign into your GitHub account to create a GitHub OAuth application.

First, login to your GitHub account, click on your GitHub profile picture, and select Settings.

Login to GitHub and select "Settings" from the sidebar menu

Then, once the new page comes up, scroll to the bottom and select Developer Settings.

Scroll to the bottom and select "Develop Settings"

Select OAuth Apps and click on New OAuth App.

Creating a new OAuth app

Define your OAuth application by naming it.

• The Homepage URL should be the URL that leads to the homepage of your website.
• The Authorization callback URL should be a site, or a page users view after their GitHub account has been authenticated.

Once you are done defining it, click Register application.

Register your application once all the info has been filled in

Next, you'll need a client secret and a client ID key to access your GitHub OAuth app on your Django project.

The Client ID is already defined once you create an application. Click Generate a new client secret to create a client secret key.

Creating a client secret key

You might be prompted to sign in. Do so to continue.

Sign in to continue

Once you log in, your client's secret key will be generated. Copy and save it on your .env file.

Copy your secret key to your .env file

Now that you’ve set up your GitHub OAuth application, let’s connect it to your Django project.

How to Integrate GitHub OAuth with Django

This part will link your Django project's GitHub OAuth application to it using the social-auth app package.

First, install the dj-rest-auth package and define it on your settings.py.

pip install dj-rest-auth

Then configure dj-rest-auth package on your settings.py.

# Application definition
INSTALLED_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "django.contrib.sites",
    "rest_framework",
    "rest_framework.authtoken",
    "dj_rest_auth",
    "allauth",
    "allauth.account",
    "allauth.socialaccount",
    "allauth.socialaccount.providers.github",
    "oauth2_provider",
    "users",
]

You'll need to enable the authentication classes for dj-rest-auth by updating REST_FRAMEWORK and AUTHENTICATION_BACKENDS on your settings.py.

Optionally, you can configure allauth if you intend to use templates. Do this on your settings.py file.

AUTHENTICATION_BACKENDS = ("allauth.account.auth_backends.AuthenticationBackend",)

REST_USE_JWT = True  # Use JWT for authentication with dj-rest-auth
SITE_ID = 1 #Set site ID

SITE_ID = 1  # Set the site ID

# Disable email verification for simplicity
ACCOUNT_EMAIL_VERIFICATION = "none"
LOGIN_REDIRECT_URL = "/"  # Redirect URL after successful login
LOGOUT_REDIRECT_URL = "/"  # Redirect URL after logout

SOCIALACCOUNT_PROVIDERS = {
    "github": {
        "APP": {
            "client_id": "YOUR_GITHUB_CLIENT_ID",
            "secret": "YOUR_GITHUB_SECRET_KEY",
            "key": "",
            "redirect_uri": "http://localhost:8000/accounts/github/login/callback/",
        }
    }
}

A Django app is required for this guide. Let's call it users. Head over to the views of the Django app and define the following code:

from allauth.socialaccount.providers.github.views import GitHubOAuth2Adapter
from allauth.socialaccount.providers.oauth2.client import OAuth2Client
from dj_rest_auth.registration.views import SocialLoginView

class GitHubLogin(SocialLoginView):
    adapter_class = GitHubOAuth2Adapter
    callback_url = CALLBACK_URL_YOU_SET_ON_GITHUB
    client_class = OAuth2Client

# Define the urls.py on the Django app
urlpatterns += [
    path('github/', GitHubLogin.as_view(), name='github_login')
    ]

How to Set Up a New Application

To specify the GitHub OAuth credentials, you'll need to log into the Django social application model. This will provide your Django project with an additional degree of protection. Because of this, changing the OAuth credentials will be simple and won't damage your existing code.

Start by logging into your Django admin, clicking Social Applications, and selecting Add Application. This will prompt you to create a new application.

On Django admin, select "Social applications"

You will be prompted to enter information on the new page.

• Select GitHub as the provider.
• Give your social app a name.
• Enter the Client Secret and Client ID created from your GitHub OAuth app.
• Select the site on Available sites and move it to Chosen sites. Once done, click Save. This will create a new application.

Create/Add a Social application

Change your site domain to localhost since this is still the development phase.

Select, "Site" to change the existing the site domain

Select example.com and change it to http://127.0.0.1:8000/ then Save.

Change your site domain from example.com to http://127.0.0.1:8000/

How to Test the Defined Social App

Once you are done defining and setting up the social Django app on your project, you will need to test it and make sure that it works.

If you open the route http://127.0.0.1:8000/auth/github/, you'll need to enter some information such as Access token, ID token, and code.

We'll manually get this information, as the front end is meant to get and parse this information.

Go to the GitHub registration page to test the defined social app

To do this, head over to https://github.com/settings/apps and select Personal access tokens then select Generate new token. Use the second option, Generate new token (classic), since this guide is focused on authenticating users just to get their GitHub user info.

On GitHub settings, select "Personal access tokens" then select "Generate new token".

Give the token a name and select scopes. Ensure you check all the user scopes. Then generate a new token.

Define your new token

Your new token should look like this. Ensure you store it somewhere safe.

Copy the generated personal access token generated by GitHub.

Head over to http://127.0.0.1:8000/auth/github/. Enter the access token generated and voilà! Your user access token and GitHub username will be sent as a response on the body.

Using your token and GitHub username ensure the backend system works

How to Implement OAuth Authentication Flow

You have successfully installed and tested the dj-rest-auth package. Next, you will learn how to test the OAuth flow and how it obtains user data from GitHub.

To test the GitHub OAuth authentication flow, you'll need to send a request to https://github.com/login/oauth/authorize.

You can do so by either using curl:

"https://github.com/login/oauth/authorize?client_id=YOUR_CLIENT_ID&redirect_uri=http://127.0.0.1:8000/auth/callback/&scope=user"

(and making sure you use the same redirect URI defined in your GitHub OAuth application) or opening https://github.com/login/oauth/authorize?client_id=YOUR_CLIENT_ID&redirect_uri=http://127.0.0.1:8000/auth/callback/&scope=user on your browser. It will redirect you to an authorization page.

Send a request to GitHub OAuth authentication flow

Click Authorize YOUR USERNAME to authorize the user.

Click "Authorize" to authorize your GitHub user

You will be redirected to a URL showing the code. With the code, you can generate the access token needed to authenticate the user.

Use the code from GitHub to generate an access token for your auth

To get the access token, send a request to this URL: https://github.com/login/oauth/access_token?client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&code=CODE

Or you can choose to use curl to send the request.

"https://github.com/login/oauth/access_token?client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&code=CODE"

This should either download the access token for you or return it as a response body depending on how you defined it. The response should look like this:

Your response from your backend authentication system

Now, with this token, you can authenticate your user when they make any request.

Conclusion

In conclusion, setting up GitHub OAuth on Django is a helpful way to enable users to log in to your web applications using their GitHub credentials.

By following this guide, you can enhance your application's security and access your users' data which improves the user experience of your Django app.

Participating in this event as either a project maintainer or a contributor gives new perspectives to either your project or your career. You also get to meet fun people.

This article will walk you through how to become a great, successful project maintainer.

Project Preparation

Ensuring that your project meets the guidelines of the Hacktoberfest team and is easy for your contributors to contribute to is essential.

You need to define the goals you want to achieve during the event. It would be helpful if you jot it down on a post-it note.

Your goal might be to draw more attention to your project or to give new contributors a safe place to make small changes that would help their careers.

README Files and Contribution Guidelines

Documentation is a huge part of your project preparation. But before you document, you need to define your goals for the project.

Your documentation should be focused on helping new contributors get started.

Create a good README file that explains your project’s usage, how to set it up, and how to contribute.

Besides having a README file, your projects should also have guidelines that new contributors need to follow.

Create a clear guide on how contributors can get involved in your project and what kinds of contributions they can make, and outline the coding standards or guidelines for the project.

Licensing and Code of Conduct

Before anyone can contribute to your project, ensure it has an open-source license. The license is there to protect you and your contributors.

An open-source project without the proper licensing file could sue contributors for copy and paste and patent rights infringement. To avoid this, select an open-source license that aligns with your project's goals.

Next, you would need to define a code of conduct to ensure that during the Hacktoberfest event, the contributors are respectful of others and inclusive.

Project’s GitHub Repository

Hacktoberfest projects are usually on GitHub. Setting up a Git repository should get you started.

If you have an account, ensure the repository is up to date. If you don’t have an account, create one.

Make sure your project’s source code and documentation are on the Git repository.

According to Hacktoberfest guidelines, add the "hacktoberfest" topic to your repository to opt-in to Hacktoberfest and indicate you’re looking for contributions.

Setting Up Issues

Issues are like a To-do list for your contributors. They can use it to track the bugs, features, or upgrades they need to get involved in.

Setting up an issue template helps your contributors to propose changes to your project.

Promoting Your Project

Once you are done setting up your project and its guidelines, you need to promote your project to reach the target audience.

This is where you use social media platforms like Twitter (X), Facebook, Reddit, and LinkedIn to reach a wider audience of people.

You would need compelling project descriptions that engage contributors to get involved.

If possible, consider hosting a Twitter space or webinar to talk about your projects, the solution to a real-world problem, and how contributors to get started.

Contributor Engagements

Once the event begins and you get contributors working on issues, you would need to engage your contributors by doing the following:

• Review and merge Pull Requests. Ensure you only merge valuable contributions.
• Give clear feedback to your contributors to improve their work.
• Appreciate your contributors. You can do this by either doing a shout-out on social media or sending thank you messages.
• Ensure they remember the code of conduct and let them know the consequences of violating the conduct.

You can also create a GitHub discussion platform where you get to interact with the project contributors. This way you can easily manage the contribution during the event time period.

Conclusion

This guide walked through the needed steps for project maintainers to make the most of the Hacktoberfest event.

By joining as a maintainer, you get the opportunity to meet people, get new ideas, and grow your project. These collaborations or contributions could make a long-lasting impact to your project.

Preparing your project, engaging with your project’s contributors, staying committed to your goals, and creating an inclusive space for all contributions could enhance your project.

Besides being a maintainer, embrace the spirit of open-source and collaboration and have fun during the event.

If you're a developer early in your career and you need to build a compelling CV, résumé, or portfolio, Render provides a free tier that offers 1GB of storage capacity.

In this guide, we'll explore how to deploy a Django app on the Render platform. The project we create will help you showcase your coding skills and projects effectively while learning about deployment.

Prerequisites

To follow along with this guide, you'll need to have a few things set up:

• An account on the Render platform
• A Git account
• PostgreSQL installed
• A GitHub account

Now let's learn how to deploy a Django web server for free. 🚀

How to Set Up a PostgreSQL Database

First, head over to your Render dashboard and create a PostgreSQL database. Click the New + button, hover over PostgreSQL, and click it.

Render Dashboard – creating a PostgreSQL database

Next, define your database settings by giving your database instance a name. You can choose to either let Render to define a name for a database and a user or define it yourself.

This guide is for beginners, we'll only define the instance name.

Creating a new PostgreSQL database

Select the free tier and click on Create Database.

Note: Every free database created on Render expires 90 days after creation. So just take note of this and upgrade if it's an important project. You can see the pricing here.

Creating a new PostgreSQL database

Once the status on your database shows Available, it means the database has been successfully created and is ready to use.

Checking the status of a newly created PostgreSQL DB

Scroll down this page to see your database settings. You'll use these settings to set up your Django app.

Database information

Next, access control lets you choose an IP address to access your database.

Once your database is created, it comes with a pre-defined access control route that allows you to access it from anywhere in the world using a single (1) IP address. Although, you can't set another route since you are using a free plan on Render.

PostgreSQL access control information

You can choose to change this or leave it as the default.

Now that we've created a database, let's set it up on a Django project.

How to Connect Your Database

Once the database is set up, you need to connect it to your Django project in the settings.py file.

Head over to your codebase and connect it.

First, Install dj-database-url

pip install dj-database-url

There are different ways to connect your database to your app's project. This guide uses the external connection URL.

Head over to your database settings on Render and copy the External Database URL.

Getting External DB URL

Next, import dj-database-url in your settings.py and define the database URL (from Render) as your database.

Note: It is always wise to add sensitive information to an .env file for security reasons.

import dj-database-url
import os

DATABASES = {
    "default": dj_database_url.parse(os.environ.get("DATABASE_URL"))
}

Next, migrate your tables to your new database to ensure the connection was successful.

If you haven't made any migrations to any db.sqlite locally, ensure you make migrations first or you won't create tables when you run python manage.py migrate.

# To make migrations if this is your first time connecting to a database 
python manage.py makemigrations

#To migrate tables set on your migrations folders
python manage.py migrate

If the connection was successful and you migrate all your tables, your terminal output should look like this:

Successful migration

You are now one step away from deploying your Django project! 🎉

Don't forget to push your codebase to a Git repo with meaningful commits.

How to Create A Web Service

This is the last step to getting your project live.

Head over to your Render dashboard. Click New + and Select Web Service.

Creating a new web service

Connect your GitHub if you haven't already. It should look like this once it's connected:

Connecting your Git to render platform

Search for the repo you want to deploy and click the Connect button. It should work seamlessly.

Then, define your repo's settings. Give your app a name and ensure you are connecting to the right branch.

Setting Django web server

Install gunicorn and change your requirements.txt in your Django project. By performing pip freeze > requirements.txt, you can update installed packages in your requirements.txt. This automatically changes your project's list of required files.

Gunicorn is a lightweight Python web server that acts as a gateway between a web application and the internet. It is designed for deployment since it manages incoming web requests effectively.

Then, push your changes to Git. Remember, you connected Git to your web service, so Render monitors the repo and auto deploys when it detects any changes.

pip install gunicorn

pip freeze > requirements.txt # To update your requirements.txt file

Ensure you add your Render web service to ALLOWED_HOSTS in your settings.py.

Next, ensure that you set the right requirements.txt as you can see in the image below. Also, make sure you use the right Python runtime and define your project's gunicorn settings on Render platform.

Once done, scroll down and select Create Web Service.

Creating a web service

Go back to the Render Dashboard and click on the Deployed Web Service to view your live link.

Deployed web service and database

That's it! You've deployed your first Django app on a free platform. Enjoy your web server for the next 90 days. 😎

Conclusion

To sum up, deploying a Django app/server or any server on Render is easy and efficient.

By leveraging Render's features like continuous integration and built-in monitoring, developers can focus more on building the app and its features rather than stressing over the app's infrastructure and management.

With SES, you don't have to worry about managing your mail server, and you can benefit from the scalability and reliability of Amazon's cloud infrastructure.

There are a few steps to setting up SES, such as verifying your domain, verifying your email address, and setting up MX records. This short guide will walk you through each step to get your SES up and running in no time.

Prerequisites: This tutorial will be a hands-on demonstration. To follow along, be sure you have an active AWS account.

How to Configure AWS SES

Step 1 – Verify Identities

First, login into your AWS Management Console account and search for Simple Email Service. Select the Amazon Simple Email Service.

Searching for AWS SES

This will lead you to an SES Console.

To start sending emails, you'll need to create an identity. This involves verifying the email address you would use to send emails. If you do not verify the email address, you can't use the email to perform any action on SES.

Note you can add a domain as an identity, but we'll use an email address for this guide. Click Create identity to verify an email address.

Creating an Identity

Next, select the Email address option and enter the email address you wish to use.

In Amazon SES, you can use a domain, subdomain, or email address as a verified identity. You may use whatever suits you best.

Verifying an Identity

We use tags to manage identities on Amazon SES. We'll skip this here, but if you wish, you can define a tag. Once you're done, click Create identity to create an identity for your SES account.

Creating an Identity for Amazon SES

Now, an email will be sent to the email address you used to create the identity. Click the link in the email to verify your email.

Verifying your email address

Once you've done that, you will see your email address on your SES account's list of verified identities.

List of verified identities

How to Create SMTP Credentials

A Simple Mail Transfer Protocol (SMTP) sends and receives messages through a mail server. In this section, you will learn how to create credentials that grant you access to the SES mail server to send and receive mail.

First, log in to your Amazon SES dashboard. Click on SMTP settings.

Amazon SES Dashboard

Then click on Create SMTP credentials to create login details to your SMTP account under Amazon SES.

Creating SMTP Credentials

You can choose to define an IAM username or use the default. Once you've done that, click Create.

Creating IAM user for SMTP

Once you create an IAM user, your SMTP details will be displayed alongside your IAM username.

A notification telling you your user has been created will be displayed at the top. Make sure you download the credentials since it is a One-Time display detail. You can download them by clicking on Download Credentials.

Created SMTP Credentials

Great! You have access to AWS Simple Email Service SMTP credentials. You can use the credentials to connect your backend to the Amazon SES server to send emails.

Conclusion

Amazon Simple Email Service (SES) is a powerful and reliable tool for quickly sending marketing, notification, and transactional emails. Setting up Amazon SES is straightforward and you can do it in just a few simple steps.

After signing up for an AWS account and accessing the Amazon SES console, you can verify and set a default email address and start sending emails using the service.

With Amazon SES, you can enjoy the benefits of cloud-based email sending, including improved deliverability, scalability, and security.

In this guide, I will discuss the differences between two popular frameworks: Tailwind CSS and NextUI.

Tailwind CSS is a framework that has gained a large following among developers due to its simplicity, flexibility, and ease of use. NextUI, on the other hand, is popular because of its scalability, performance, and flexibility.

This article will compare the critical features of the two frameworks, their pros and cons, and their suitability for different project types.

Whether you are a developer looking to select the best framework for your project or you're just curious about these tools, this article is for you.

Here's what we'll cover:

• What is Tailwind CSS and what are its pros and cons?
• What is NextUI and what are its pros and cons?
• How to decide between Tailwind and NextUI

Let’s dive in! 🚀

What is Tailwind CSS?

Tailwind CSS is a utility-first CSS framework – that is, it's a framework that focuses on functionality rather than its looks or UI. Adam Wathan, a Canadian Software developer and entrepreneur, built Tailwind CSS.

Tailwind allows you to completely customize your utility classes without leaving the HTML. Tailwind CSS offers a fast and easy way to style your websites.

Tailwind CSS is highly customizable. This means as a user, you can modify the fonts, colors and other design elements to match your web design preferences.

This framework also has faster load time because of PurgeCSS (which removes unused or unwanted CSS styles from your final build resulting in smaller file sizes).

Pros of using Tailwind CSS:

Just as everything has advantages and disadvantages, here are the advantages of using tailwind CSS:

• Tailwind is easy to learn and use for first-time developers.
• Tailwind uses a few lines of code to create flexible designs.
• Tailwind can easily convert a design to reusable components since it is a utility-first framework.
• Tailwind is a guide and avoids using unfamiliar names for CSS classes and ids.
• Tailwind can effortlessly be customized to suit the developer’s needs.

Cons of using Tailwind CSS:

And now here are the disadvantages of using Tailwind CSS:

• Tailwind contains large CSS files because it provides low-level CSS classes, so when styling, the files may be too large and complex to maintain over time. This also affects the performance of the website or application.
• Tailwind may have many low-level classes, but it is hard to override the styles of specific elements when changing designs or styling specific elements.
• Tailwind is not always the best framework for some projects. It is undoubtedly a powerful tool, but specific design requirements may not be achievable using the available classes when working on a project. Tailwind is best for projects that involves a lot of styling UI and customizing design elements such as Prototyping, Dashboards, E-commerce websites and lots more.

What is NextUI?

NextUI is a component-based CSS framework, which means it provides a set of pre-designed components you can use at any time. Examples include buttons, forms, navigation bars, navigation menus, and more.

NextUI is built and maintained by the Vercel team. The beauty of NextUI is that it gives you a customizable template, so you don’t have to write much CSS code to create a responsive website.

The downside of using this framework is that developers won’t have 100% control of the design as the components are limited by NextUI.

In addition to its core UI components, NextUI offers developer tools such as automatic code splitting, server-side rendering, and built-in support for libraries like GraphQL and Apollo.

Pros of using NextUI:

Just as everything has advantages and disadvantages, here are the advantages of using NextUI:

• NextUI is highly scalable when handling large and complex applications if the application grows. It doesn’t slow down when handling such large files.
• NextUI is very flexible and built to suit the user’s needs or tastes.
• NextUI has a large, reliable community so getting help when using the tool is stress-free.
• NextUI has an extensive range of pre-built components and features, which saves the developer's time when building.
• NextUI is built on React, making it user-friendly to build a JavaScript application.

Cons of using NextUI:

And now here are the disadvantages of using NextUI:

• NextUI has a large footprint compared to other frameworks despite being built on ReactJS. This can also affect its performance if the developer does not fully understand how to navigate NextUI.
• NextUI may not be the best option when building an application that does not involve or use ReactJS.
• NextUI may be relatively easy to use but has a learning curve that may be difficult to understand for those who don’t use React.
• NextUI requires more attention in setting up and configuration because it offers a range of developer tools for customization.

How to Decide Between NextUI and Tailwind

If you are working on a React application for a large-scale project, NextUI is the best choice as a CSS framework. But if you are working on an application that requires you to focus on specific functionality or design requirements, Tailwind is the best choice for you.

Conclusion

In conclusion, Tailwind CSS and Next UI are different tools for developing web and mobile applications.

Tailwind CSS is a utility-first CSS framework designed to help developers build a custom user interface quickly. NextUI is a component-based framework designed to help developers improve the performance and scalability of the application.

Tailwind and NextUI each have strengths and weaknesses, and the best choice for your project depends entirely on the application’s design requirements, needs, and goals.

Tailwind CSS best suits developers looking for a simple solution to build a custom user interface. In contrast, NextUI is best suited for developers looking for CSS templates, so they can focus on other parts of the application, like scalability.

In the end, pick the best framework for you based on your preferences and skills as a developer. Before choosing, carefully evaluate the pros and cons of each tool to make an informed decision when building the best possible application for your users.

But software testing is a complex topic and can be a bit difficult to understand.

In this article, I'll explain the major topics in software testing and how this practice can help you.

Table of Contents:

• What is Software Testing?
• Types of Software Testing
• Different Types of Functional Software Testing
• Software Testing Principles
• Why is Software Testing needed?
• Conclusion

What is Software Testing?

Software testing is the process of making sure your software/app works as it should. There are various methods you can use to test your code, and each testing method has different requirements.

For instance, unit testing involves writing test cases to ensure the code works as it should, and Beta testing consists of testing the preview version of the software or app to make sure users can use the product.

Software testing is integral to the process of building good software that works as it should. It also helps improve productivity and performance. Testing is an important part of the Software Development Life Cycle (SDLC).

Other benefits of testing your code include preventing bugs, reducing cost, and reducing time of development.

Types of Software Testing

There are two general types of software testing:

Functional Testing:

Functional Testing is a software testing method that validates the system against the customer's requirements or specifications.

This type of testing aims to test each function of the software by providing the correct input and ensuring the output is right.

For examples, let's say you write a test case to test creating a user. The test case provides the correct input (email, first name, last name and password) and ensures the output (success message) is accurate, as well.

Functional testing checks that everything is functioning properly by emulating business scenarios based on applicable requirements.

Non-functional Testing:

Non-functional testing is a software testing method that tests for end-user experiences, such as performance and reliability under load. This could either make or break a user experience.

When your code fails at non-functional testing, it may not cause an issue that user would note but it can flag a problem in the system.

Non-functional testing is just about testing the software to know how it responds to load on the system.

In this guide, we will focus on Functional Software Testing.

Different Types of Functional Software Testing

There are different types of software testing, and each has a specific aim. We'll look at each one quickly now.

Unit Testing:

Unit testing is a type of software testing that validates how each software unit performs and whether that specific piece of code does what it should. A unit is the smallest testable component of an application.

The aim is to confirm that each unit of software code works as expected. You do unit testing during the coding (development) stage or phase. Developers write these tests as they go.

Unit tests isolate possible bugs in your code and help you correct them. A unit could be a single function, method, procedure, module, or object.

Code Snippet of a unit test case in Python

Code Snippet of a unit test case in Java

Integration Testing:

Integration Testing is software testing which helps ensure that software components or functions work together properly. This is the second phase of the software testing process that comes after unit testing.

In this type of testing, units or individual software components are tested in groups. This testing method mainly focuses on exposing defects in interactions between integrated components and units.

System Testing:

System testing involves the process of testing integrated software. The aim is to evaluate the system's compliance with specify requirements.

In system testing, the quality assurance team evaluates how each component of the application or software work together in a full, integrated environment.

Acceptance Testing:

Acceptance testing is a software testing method where a system is tested or checked for acceptability. It evaluates the system's compatibility with the business requirements and assesses whether it is acceptable for delivery.

It is also known as formal testing performed to fit user needs, requirements, and business processes. It determines if a system satisfies the standard business criteria and if users or customers will be able to accept it.

Acceptance testing is the last stage of software testing done after system testing and before making the system available for public use.

Regression Testing:

Regression testing ensures that a component continues working as it should, after including additional components in the program. You perform regression testing when something changes, such as adding a new module to the program.

This type of testing represents the complete testing of executed test cases that are re-executed to ensure the current functionalities still work just fine.

Alpha Testing and Beta Testing:

Alpha testing is also known as initial validation testing. It is an aspect of acceptance testing done before the product is given to the consumers or users. QA (Quality Assurance) testers usually do this. Alpha testing is done internally by the QA team.

Beta testing is also known as second phase of validation testing. But this type of testing is done externally, which means the public does it.

The version of the code/software for this phase of testing is released to a limited number of users for testing in a real-time scenario. For instance, freeCodeCamp's math curriculum is available for beta testing here.

Software Testing Principles

Everything in tech has principles. These are guidelines to help you build better software and avoid errors.

Here are some software testing principles you should follow when writing tests for your code:

Testing aims to show the presence of defects, not the absence:

Software testing aims to spot software failures. This reduces the presence of faults and errors.

Software testing ensures defects are visible to the developer but doesn't guarantee defect-free software. Multiple types of testing can't even ensure error-free software. Testing can only decrease the number of errors.

Exhaustive testing is not possible:

Exhaustive Testing is the process of testing software for all valid and invalid inputs and pre-conditions.

This method of testing is not realistic because test cases presume that the software is correct and it produces the correct output in every test case. If you truly try to test every aspect and test case in your software, it will take too much time and effort, and it's not practical.

Perform early testing:

Testing your software at an early phase helps avoid minor bugs or errors. When you can spot errors at an early stage of the Software Development Life Cycle(SDLC), it's always less expensive. It is best to start software testing from the beginning of the project.

Defect clustering:

Defect clustering refers to when most of the problems you find occur in just a few parts of the application or software. If you can identify the modules or areas where these defects occur, you can focus most of your testing efforts on them.

Keep the Pareto Principle in mind when testing your code: 80% of software defects tend to come from 20% of the modules.

Beware of the Pesticide paradox:

This principle is based on a theory – "the more you use pesticide on a crop, the more immune the crop will eventually grow, and the pesticide will not be effective."

When you repeat particular test cases over and over, you will see fewer and fewer new bugs. So to find new bugs, update your test cases and run them once you add new test cases.

Testing is context-dependent:

Testing is context-dependent, which means that you should test your software based on its needs, functionalities, and requirements.

Your test approach should depend on what your software does. Not every software needs the same type/method of testing because every application has its unique functionalities.

For instance, when testing an eCommerce web app, you will focus on its functionality to display products, so you will test how it shows products to end-users. When dealing with an API, you will focus on the response the API returns when an endpoint is called.

You wouldn't necessarily use the same test cases for both – that is what it means that testing is context-dependent.

The absence of errors is a fallacy:

If you build software that is 99% bug-free, but it doesn't follow user requirements, it is not usable for end-users.

Know that it is very much necessary that your 99% bug-free software still meets or fulfills your user requirements. It is important to write test cases to find errors in the code, but you also need to test your software for your end-users (with them and how they'll use it in mind). The best way to do this is to carry out beta testing.

Why is Software Testing Needed?

Besides making sure your software is bug-free and meets user requirements, software testing has other advantages.

Software testing improves security:

When building software, security is a crucial part of your planning. This is because vulnerable software could jeopardize you users and their information, as hackers can use stolen info for malicious purposes.

As a product undergoes testing, the end-user can count on the fact that they will be getting a reliable product and their details will be secured and safe. So users are more likely to get a product that is free from vulnerabilities with the help of software testing.

Software testing improves product quality:

You want your software or product to be bug-free, low-risk, and effective at what it should do. And you can achieve this by including test cases and other testing methods when building out the code.

In addition, you won't know how good your product is until you test it. This helps you provide the best product version before it gets released (and discover any inconsistencies or pain points along the way – so you can improve them).

Software testing improves customer satisfaction:

For instance, let's say you download a new app and try to use some of its functionality – but it shows an error. This will probably frustrate you, and you might not want to use the app again, right?

This is exactly why software testing is important. It can help you discover such errors and detect them before you release the product to the user, and gives the developers a chance to prevent the error.

By investing in software testing early in the development stage, you are letting the users know that you care about their experience. It could also help you create a solid long-term customer relationship.

Software testing saves money:

Software testing can save you a lot of money – but how?

Each stage of development involves many things, such as clear communication and coordination between multiple teams, and each step has a laundry list of things that could go awry.

Catching those errors when the product is live is a horrible experience because you may have to handle PR, retasking fixes, and trying to sort the problem in real time.

In addition, your users won't be able to access the app while you're fixing it, which defeats the app's purpose and provides a bad user experience in the meantime. Software testing helps resolve this stress, and once live, your user can enjoy your app/product to the fullest.

Conclusion

In conclusion, software testing is a crucial part of development. It can help save your team a lot of trouble, and it feels great to create a usable, bug-free product that users enjoy and recommend.

If software testing interests you, you can check freeCodeCamp's QA certificate course here to learn more about QA testing. QA testers are techies that focus on testing softwares and apps for errors.

But the good news is you don't necessarily have to be a developer to be in the world of tech.

This article is a guide for people struggling with the transition to tech. It will explain various careers in tech that you can consider. We'll also discuss how to know whether a particular path suits you or your personality.

This is based on my views and experience, but I hope my insights will prove helpful.

Table of Contents

• UI/UX Design Path

• Frontend Path

• Backend Path

• Data Analysis & Data Science Path

• Cyber security Path

• Graphic Design Path

• Program Management Path

• Human Resources Path

• Growth Management Path

• Business Development Path

• Community Management Path

• Developer Relations Path

• Technical Writer Path

• Quality Assurance Path

• Motion Designing Path

• Digital Marketing Path

• Mobile Development Path

• Developer Operations Path

• Game Development Path

Possible Careers in Tech

UI/UX Design

UI/UX Illustration

If you love aesthetics and enjoy styling things, then UI/UX design might be your career.

What is UI/UX Design?

UI stands for User Interface and refers to the screens, pages, and visual icons that users interact with on a webpage or in an app (buttons, icons, and so on). A well-designed UI helps non-techies and all end-users interact with a product or a service online.

UX stands for User Experience and involves helping a product or service improve its customer's service. A good UX can also help grow followers for the brand.

As a UI/UX developer, your job is to design and build out a user's experience for a brand or company.

A UI/UX developer must know and understand how to use the following:

• Wireframing: A wireframe is a webpage layout stripped of visual design. You use it to prioritize page elements based on user needs.

• Prototyping: A prototype is a sample or simulation of a final product used to test and gather feedback. Low-fidelity prototypes might be sketched on paper and don't allow user interaction. High-fidelity prototypes are typically computer-based and allow for mouse and keyboard interaction.

• Mockup: A mockup allows designers to get an idea of a realistic visual model of a final webpage or application.

• User flow: A user flow is a way to map out each user's steps when using a product or service. This helps improve the user experience.

What tools do I need to become a UI/UX Developer?

If you're working as a UI/UX developer, you'll likely use tools like:

• Adobe XD

• Figma

• Photoshop

• Sketch

There are lots of tools, but these are the most popular.

A UI/UX developer designs websites and web apps and helps improve user experience with the need-to-knows mentioned above. You can get inspiration from Behance or dribble if you wish to go down this path.

Here are some resources to help you get started as a UI/UX designer:

• Figma Tutorial for UI Design - Course for Beginners

• UI / UX Design Tutorial – Wireframe, Mockup & Design in Figma

• UX Design Tutorial for Beginners

Frontend Development

Frontend Tools Illustration

If you love creating websites, you should consider frontend development.

A frontend developer ensures that a visitor can easily interact with a webpage. They use design tools, various frameworks and libraries, and coding to build websites.

Frontend devs are also client-side developers because they directly build the elements on websites and applications with which users and clients interact.

The leading web technologies used by frontend developers are:

• HTML (HyperText Markup Language):

HTML lets you build the skeleton of webpages and websites. The markup language defines the web. You can think about it as the structure of a house because it holds all the text and defines every header 0n a website.

• CSS (Cascading Style Sheets):

CSS is responsible for making the website beautiful. You can think of it like the decor of a house. You use it to give your pages color, animations, and more after the HTML has displayed the text.

• JavaScript:

JavaScript handles the responsiveness of the website. It gives life to a website, helps make it look fabulous on every device, and makes it more interactive.

You will need basic knowledge of these languages to build a unique and interactive website successfully. Knowing only one of the mentioned tech skills won't be enough to build production-quality applications because you will just be able to create a half-useful website.

Sometimes, frontend developers work hand-in-hand with UI/UX developers.

What tools do I need to know to become a Frontend Developer?

A code editor or an IDE (Integrated Development Environment)

A code editor/IDE is where you'll write your code, debug it, and preview written code.

There are many editors/IDE to choose from, but the most popular ones are Visual Studio Code, Atom, and Sublime text editor.

Chrome Developer Tools

You use Chrome DevTools to debug real-time applications on Chrome. It gives you an understanding of and access to important internal information of a web application. DevTools also helps you understand how to optimize the loading flow and what the browser is doing now.

Git and GitHub for version control

I know what you are thinking – what is a version control system? It is a system that helps you review your code in stages and keep track of your (and others') revisions. Git is a version control system, and GitHub is an online hosting service for Git repositories.

Say you are working on a landing page, and you messed up the footer, and in the codebase, it seems hard to debug. You can quickly go back to previously committed code on your repository and see your last change(s). Although, you can only see your previous commit when you commit to your repo.

GitHub helps team members work together more efficiently, and you can use it to contribute to open source projects.

Here are some resources to help you get started in Frontend Development:

• Frontend Developer Guide for 2022

• Frontend Development with HTML, CSS, JavaScript

• Responsive Web Design Course

Backend Development

Backend Tools Illustration

If you love working with and building things that depend on you, you should be a backend developer.

A backend developer builds and maintains technologies or software necessary to power client-side development components. They are also called server-side developers.

Their work includes:

• Building/maintaining databases

• Working with data and application integration

• Working with APIs

• Building out the core application logic

What tools do I need to become a Backend developer?

Backend devs use almost the same tools as Frontend developers. Here's what you'll find helpful:

• Code editor/IDE: This is used for writing code, debugging, and previewing codebases.

• Chrome developer tools: This helps you debug your code.

• Git and GitHub: This helps you review your code in stages and makes team-building, collaboration, and open source contributing easier. Any developer can contribute to your project if the repository is public.

• SQL or NoSQL server: SQL stands for Structured Query Language. This helps you query databases and interact with them while building an application.

• Knowledge of a database

Here are some resources to help you get started in Backend Development:

• Backend Development and APIs certification

• Backend Roadmap

• Back-end Development and APIs - FreeCodeCamp Tutorial

Data Analysis and Data Science

Data Science/Analysis Skills Illustration

Consider a data analyst career if you love calculating, mathematics, or statistics.

Data analysis involves examining, transforming, and arranging a given data set in specific ways to study its parts and extract useful information. It deals with interpreting, analyzing, and visualizing data.

In layperson's terms, data analysis involves gathering insights from data to aid business decisions.

Data science handles data using machine learning, algorithms, and statistics. It is the statistical part of the data field. Data scientists collect, clean, and interpret data sets for surveys. So data science involves statistically analyzing data.

It's always better to start as a data analyst and then transition to data science because data analysis is the foundation of data science. Although they may be on the same path, there is a fine line between data science and data analysis.

Data is present in every industry, so data scientists and analysts are needed everywhere.

Essential technical skills to have for Data Science:

• MySQL

• Python programming language

• Mathematics

• Statistics

• R programming language

What tools you would use in this field:

• Microsoft Excel

• Google Spreadsheets

• Tableau

• SQL Server

• PowerBI

Here are some resources to help you get started in Data Analysis and Data Science:

• Discover Data Analysis

• Data Science For Beginners

• Data Analysis certification

Product Management

Product Management Skills Illustration

This is for you if you are great at organizing products and teams.

A product manager manages and coordinates product development projects. The product manager is the voice of the customer on the team.

They ensure that the product being built contains the features and requirements needed to satisfy the customer. They're also in charge of drafting out a roadmap for that product, from imagination, all the way to launch. And they are the ones who decide what feature to include in v1 or V2.

Their responsibilities include:

• Understanding user needs,

• Drafting out roadmaps for the product being built.

• Defining a vision for the products

• Developing competitive analyses

• Prioritizing product features

And lots more.

Common tools product managers use:

• There are many tools for user tracking and analysis such as Pendo or Amplitude. These apps give insight into users' activity on the software or website.

• Product Plan is a road mapping software to draft out and manage the product plan. They can also handle version-control issues that can slow your product's progress.

• Survey Tools such as Typeform are very handy. PMs use them to carry out customer or user surveys to help improve the product to users' needs. A product manager can easily track and analyze the results using these tools.

• Feature flagging tools such as Split.io help teams quickly turn specific features when users have flagged them. This is useful during a notable feature or product launch or testing process.

• Flowcharting tools such as Visio help create product development workflow and help the product manager structure the user journey on the product.

Here are some resources to get started in Product Management:

• Product Management Fundamentals

• Introduction to Product Management

• Product Management Tutorial for Beginners

Cybersecurity

Cyber Security Skills Illustration

If you are passionate about security, consider a career in cybersecurity.

Cybersecurity involves everything from encryption to finding and protecting against malware or viruses to hacking to find security vulnerabilities in a system so they can be fixed.

A cybersecurity specialist protects digital information for individuals, companies, firms, and the government.

Their tasks include:

• Testing, analyzing, and implementing security system developments

• Managing system vulnerabilities

• Responding to security threats and attacks

• Developing threat prevention strategies

• Reporting directly to administrators and executives

Tools cyber security analysts use:

• Network security monitoring tools such as Splunk or Argus. These tools keep track of network threats and analyze network data.

• Encryption tools such as VeraCrypt and TrueCrypt. These tools are used for encryption by scrambling plain text to code that is not accessible to unauthorized users.

• Vulnerability scanners such as Nikto and Burp Suite. These tools scan software to identify security vulnerabilities using SQL Injection and cross-site scripting.

Here are some resources to get started in Cyber Security:

• Complete Ethical Hacking Course - Network Penetration Testing for Beginners

• Cyber Security Full Course for Beginner

• Cyber Security Training Course

Graphic Design

Graphic Design Skills Illustration

If you love designing flyers, logos, and other graphic elements, consider a career in graphic design. Many people will argue that graphic design is not a technical career, but it is because it helps bring ideas to life, like UI/UX designing.

A graphic designer is in charge of digitally beautifying a company's brand, assembling images that tell consumers about the brand, and creating motion graphics for a brand.

Graphic design as a tech career involves:

• Creating layouts

• Digital editing

• Typesetting

• Presenting design products

Some Graphic Designer tools you should know:

• Adobe Illustrator

• Procreate

• Adobe Photoshop

• Affinity

• Canva

These tools will help you get the most out of your designs, and they're used by designers all over the world.

Here are some resources to get started in Graphic Design:

• Graphic Design Tutorial For Beginners

• Photoshop for Beginners

• Graphic Design Crash Course

Program Management

Program Management Skills Illustration

If you love creating and managing structures, consider being a program manager.

A program manager oversees the fulfillment of company goals. They manage the practical programs and coordinate activities between multiple projects without executing them. They also focus on implementing programs, program strategies, and delegating tasks.

They are involved in:

• Sales process

• Employee training

• Creating marketing plans

• Opening new facilities

• Product launches

Tools used in Program Management:

• Agile tools such as Trello and Jira.

Here are some resources to get started as a Project Manager:

• Program Management Standard Summary & Introduction to PgMP

• Everything About PgMP (Program Management Professional)

• Overview of Program Manager

Human Resources

Human Resources Skills Illustration

If you are good with people and enjoy helping them resolve conflicts and issues, you might consider becoming an HR specialist. HR stands for Human Resources.

Human resources management is recruiting talents and developing a solid company's workforce. The HR department identifies skills or human resources in a company, evaluates potential candidates, and hires talent. They are also in charge of advertising a position for a company.

An HR specialist screens, recruits, interviews, and places new employees.

Other HR responsibilities include:

• Handling employee relations

• Handling payroll

• Managing benefits and training for employees

• Consulting with executives on strategic planning

Tools and techniques used by HR Personnel:

• Programmatic Job Advertising Tools

• Pre-employment Assessment Tools

• Talent Management Solutions

• Expert Judgement

• Networking - they use a platform like LinkedIn to reach out to talents.

Here are some resources to get started with Human Resources:

• HR Basics

• Complete HR Generalist Tutorial for Beginners

• Principles of Human Resources

Growth Manager

Growth Skills Illustration

If you are passionate about making things better or bigger, a career as a growth manager might be for you.

A growth manager handles the execution of growth strategy for a business's product to direct consumers. Also, they coordinate initiatives with key financial partners.

Growth managers handle the company's financial growth from sales and marketing to networking and business stakeholder management to people management and work with almost every department. They set goals for workers of every department.

Tools used in Growth Management:

• Expand

• Zapier

• GrowthBar

• Colibri

• Airtable

These tools are all used to track the activity growth in a company or a product.

How to get started as a Growth Manager:

• Growth Manager course

• Growth Hacking for Beginners

• Growth Management courses

Business Development

Business Developer Skills Illustration

This career is for you if you are great at building relationships and are 100% business-oriented.

A business developer or business development analyst is in charge of helping organizations gain better brand recognition and financial growth.

They bring up ideas, initiatives, and activities that help improve a business, including increasing revenues, growth terms of business expansion, and profitability by building strategic partnerships and making decisions for business strategy.

Other business development job responsibilities include:

• Coordinating events with company executives

• Reviewing current market trends

• Proposing new business ideas to improve revenue

• Building relationships with potential partners

At a large tech company, a business developer works with the non-technical teams and the CEO or board to help grow the business.

Tools used for business development:

• Social Management Tools

• Email Lists

• Customer Relationship Software (CRM)

• Project Management Tools such as Jira or Accelo

• SEO (Search Engine Optimization) Tools

Here are some resources to get started with Business Development:

• Business Analyst Full Course In 2 Hours

• Business Development Course

• Business Analytics Course

Community Manager

Community Manager Skills Illustration

If you are good with people, can drive conversations in a group, and are good at motivating people, this is for you. Every tech community needs a community manager, and if you are great at communicating with people, this is definitely for you!

A community manager handles communication and serves as the face of the company. They act as the voice, face, and tone of the community. Also, they are responsible for the digital engagement to build the community's presence and trust online and in person. They are the liaison between the community and its users.

Community managers are involved in:

• Communication

• PR (Public Relations)

• Social media management

• Events

• Content creation

Tools used in Community Management:

• Notion

• Trello

• AhoyConnect

• Orbit

Here are some resources to get started with Community Management:

• Community Management Masterclass

• Community Management course for an engaging an audience

• Meta Community Manager Online Courses

Developer Relations (DevRel)

Devrel Illustration

If you love marketing, DevRel is a career path for you.

Developer Relations has job responsibilities similar to a Community Manager, Tech Author, Developer Evangelist, Developer Advocate, and sometimes even Growth Hackers and Marketers.

Their prime responsibility revolves around building a positive relationship with the developers on their team. They work between product, engineering, and marketing teams.

To work in the DevRel tech space, you'll need to:

• Be part of a community

• Build a presence in the community

• Learn how to interact with the community members

• Create content such as blog posts, articles, or videos

There are no specific tools developer advocates use because their roles are similar to other fields, so I will mention some essential tools:

• Notion

• Trello

• Code editor - because they often code as well.

Here are some resources to get started in Developer Relations:

• Intro to DevRel

• A complete guide to DevRel

• Prototyping your career in Developer Relations

Technical Writer

Tech Writer Skills Illustration

This is the best fit for you if you love writing and sharing your knowledge about various tech-related topics.

A technical writer generates innovative ideas for content (or works on assignments) while working as a team. They research products, services, technologies, and concepts and document/explain them clearly and concisely so anyone reading can understand how the product or tool works. A technical skill such as programming is needed to excel in this field.

Job responsibilities of a technical writer include:

• Generating ideas for content and workflow solutions

• Meeting with experts to ensure they appropriately cover and understand specialized topics

• Analyzing and explaining information about products, tools, policies, form documentation, and procedures.

• Also, they review and edit content developed by other team members.

Tools used by technical writers:

• Markdown editors such as StackEdit, Typora, Dillinger, and IA.

• API Documentation tools such as Bump, Redocly, Postman, and GitBook.

• Publishing Tools such as Document360 and Adobe Robohelp.

• Editing tools include Grammarly, Copy.Ai, Adobe Acrobat, Dropbox, Google Docs, and Evernote.

• Media management tools such as Snipaste, Loom, and Camtasia.

Note that different organizations use different tools, but those mentioned above are the most common tools for each category.

Here are some resources to get started with Technical Writing:

• Technical Writing Course

• Tech Writing Workshop

• A guide to Technical Writing

• Technical Writing for Beginners

Quality Assurance Testing

QA Skills Illustration

If you love writing and testing code, this is for you.

Quality Assurance (QA) testers are critical in delivering consumers high-quality, functioning software and web applications. They test and evaluate new and existing programs and help identify and remove bugs, glitches, and other user experience issues.

Tools QA Testers use:

• TestRigor

• Testim

• Kobiton

• Kualitee

Here are some resources to get started as a QA Tester:

• Quality Assurance Certification

• Software Testing Full Course

• QA Manual Testing Course

Motion Designer

Motion Skills Illustration

If you love CGI, this is for you.

A motion designer creates artwork for the web, television, and films, which include movie clips, trailers, commercials, and so on.

They use special effects called visual effects, animation, and other cinematic techniques to bring life to their created works.

Tools used in motion designing:

• Adobe After Effects

• 3D Blender

• Cinema4D

• Maya

Here are some resources to get started as a Motion Designer:

• Motion Graphics Tutorial

• Intro to Motion Design

• Motion Design Courses

Digital Marketing

Digital Marketer Skills Illustration

If you love selling products online, this is for you!

A digital marketer helps maintain a brand by working on marketing campaigns. It is online marketing because it promotes brands and connects potential users or consumers to the product through the internet.

Digital marketing is another form of digital communication. This is not limited to email, social media, and web-based advertising but also includes text and multimedia messages as a marketing channel for marketing.

Digital marketers' duties include:

• Creating content to help marketing campaigns

• Doing market research

• Strategizing with the marketing team

Tools used for digital marketing:

• Sprout Social

• Loomly

• Audiense

• SendGrid

• Ahrefs

Here are some resources to get started as a Digital Marketer:

• Digital Marketing Tutorial For Beginners

• Digital Marketing Course in 7 Hours

• Free Digital Marketing Course

Mobile App Developer

Mobile Developer Skills Illustration

If you love creating apps, this is for you.

The mobile development tech space is vast, and the tools and technologies you would use would depend on what area you chose to specialize in – Andriod app development and iOS development.

A mobile developer converts code into user-friendly applications. They work with other developers to develop functional mobile applications in a fast-paced environment.

Tools used for android development:

• Android Studio

• Eclipse

• Instabug

Tools used for iOS development:

• Xcode or App code

• Transporter

• Fabric

Some key responsibilities of app developers:

• Design the application,

• Test the application,

• Release the application

• Support the application.

Here are some resources to get started as a mobile developer:

• Android Development for Beginners - Full Course

• iOS Development Tutorial For Beginners

• Flutter Course for Beginners

DevOps

DevOps Skills Illustration

This is for you if you love working with infrastructure and cloud technologies.

A DevOps engineer works directly with developers and IT staff to supervise the release of code and brainstorm ideas for engineering and coding.

Their responsibilities include:

• Implementing automation tools and frameworks for automatic code deployment,

• Quality control and management of the code base,

• Designing procedures for system troubleshooting and maintenance and

• Writing scripts for service quality analysis, monitoring, and operation.

Skills you need as a DevOps engineer:

• Linux

• Basic knowledge of Python programming language

• Knowledge of cloud platforms.

Tools used as a DevOps engineer:

• Build tools such as Gradle and Apache.

• Package managers such as Npm and Mache

• CI/CD tools such as Jenkins.

Here are some resources to get started as a DevOps engineer:

• DevOps Tutorial for Beginners

• Microsoft Certified: Azure Fundamentals

• DevOps Engineering Course for Beginners

Game Development

Game Design Illustration

If you love games, this is a tech path for you.

Game designers translate design ideas into a functional game code. They create web games, mobile games, and iOS games.

Their responsibilities include:

• Coding the base engine of the game,

• Generating game scripts and storyboards,

• "Polishing" the game, maintaining the code, fixing bugs, and ironing out reoccurring problems

• Contributing to audio and animation design, and

• Creating game specifications and designing expansion packs.

Tools used as a game developer:

• GameFroot

• Flowlab

• Splender

• Construct

Here are some resources to get started in game development:

• Learn Unity - Beginner's Game Development Tutorial

• Basic Principles of Game Design

• Introduction to Game Development with Unity

Conclusion

Now that you have different options to get started in the world of tech, I hope you become less confused.

Choose a path and get started – the tech space is vast, so roles are constantly opening up. Don't fret because learning can be challenging. And remember – even senior techies suffer imposter syndrome.

How Does an API Work?

How an API works

Imagine you are in a store and want to buy a soda. But you can't just walk in and take one because you are an outsider – an external user – so you need a link (talking to someone and paying for your soda) to get what you want.

You can't link to the shelves – the database – because they can't move or talk. So this is where the seller – the API – comes in. The seller serves as an intermediary between you and the item – the data (soda) – you want.

Now, you have a link to communicate to the items on the shelves, so you request the soda. Then the seller searches for the soda brand and the flavor you want and gives it to you. You pay, take it, and leave.

What just happened?

The seller (acting as the API) queried the shelves (the database) for the requested data.

As you may know, data sets come in different forms. The API queried the database for a table and then searched the table for detailed data. Finally, the API sent you the data you needed.

Let's say you request a Fanta soda.

Your request:

Your Response:

The response is always in JSON (JavaScript Object Notation) format. This is how an API works.

How to Design an API

When designing an API, you should consider some best practices which can help you optimize your APIs and their response times.

Name the API Properly

Suppose you are creating an API that sends you the data of a particular user. It wouldn't be wise to name the API simply GetUsers because it means you want to get all users on the database, and the external user that will call this API will be expecting a response from what you want to give.

Examples of a Good Name for an API

• Use a clear, concise name:

If you want to query a database of apples, it wouldn't make sense for you to name the API "api/fruits/."

Although Apple is a fruit, it isn't what the end-user wants. The end-user wants a particular fruit, so name it "api/apples/".

• Use words that explain the query:

Use words like nouns that represent the resource's contents in the API, for example "api/stationery/pens". This explains the API queries for all pens in the stationery database.

This would be instead of, for example, "api/stationery/write".

• Avoid special characters:

This may confuse the end-user if they see an API like "api/fruits%20?/apple". They will not understand what this API does or how it queries, or what information it will get.

Define Parameters When Necessary

Try as much as possible to avoid using additional parameters unless you need them. Some examples of required parameters when creating a RestFul API are:

• Request headers and cookies: This parameter uses a small piece of data that a server sends to a user's web browser.
• URL query string: These parameter elements are inserted in your URLs to help you filter and organize content or track information on your website.
• URL paths: This is a required parameter that gives the end-user or whoever calls the API a way to get the right information, such as: "/users/", "/users//", "package/".
• Body query string/multipart: This parameter sets the HTTP method for the question or API, such as POST – for sending data, or PUT – for updating the data in an API.

So when do you need parameters? Let's say external users are making multiple queries on an API service, and the API will query other services to get users' desired data.

This will slow the API service, but additional parameters are helpful in this case.

Define Response Objects

In layperson's terms, Response Objects are properties of a response when an API is triggered or called. Some response objects are:

• Title: This is the display title of the response, such as User if the object is returning some user information. This is a required response object.
• Subject: This is the subject of the response, such as the user and any other user-related information the API is meant to relate.
• Sender_id: This is the ID of the sender or user created. This is an option response object, meaning you can choose not to add it to the response object if it isn't needed.
• Categories: This is the category of the response object. If the API returns a user's information, the category will be Users.

Many developers create a response object that contains everything from the API service – even unnecessary information – in the hope of not changing the response object when the user asks for more details (as this takes more network requirements).

Unfortunately, this is a terrible API design practice. When creating a response object, it is wise only to return what the external user will need because building a large microservice will affect the performance and more.

Define Error Objects

When you're returning an error message when an external user queries the database, the message should be clear and concise – not just a generic error message like "Error Found" or "Error occurred."

This should be the title of the response, and the data or subject section should explain what sort of error occurred.

This is my personal take when creating an API error message. Do not return an unnecessary error message. Let's say some user data has a maximum character length of 5, and an external user queries the API for user data with a character length of 8.

Instead of doing this:

Do this:

This explains what the end user did wrong and the formatting shows the end user that this error is a client error.

Use Correct HTTPS Request Methods

When defining an HTTP method%20operations%2C%20respectively.) for an API service, you must use the correct method to let users query the right way. Some HTTPS methods are:

• POST: Use this method if the end-user is to send data to the API.
• GET: Use this method if the end-user is to retrieve data after the API queries the database.
• PUT: Use this method if the end-user updates existing data in the database.
• PATCH: Use this method if the end-user needs to correct or replace existing data in the database.
• DELETE: Use this method if the end-user deletes any information or data from the database.

Imagine an external user wants to query the user table by sending an ID, and the API method you designed uses the POST method. This will limit the users' queries as the end-user isn't adding or creating data, and the user can not query the way they should be able to.

Instead, using the GET method with an ID as a parameter would be best, and it should go this way:

This will give users the option to query using an ID and get specific data.

I suggest knowing all the HTTP request methods before defining a method and returning the correct ID when requested.

Make sure the routing is crystal clear so users can quickly call the API service I showed earlier.

Don't Create Side Effects on the API

A side effect is, for example, when an external user queries an API for the user's first name but it returns the ID and full name.

When creating an API, try not to define everything in one function as much as possible. If the API sets many flags or does many tasks simultaneously, it should be split into multiple APIs. That's where atomicity comes to play.

Atomicity is when multiple operations are grouped into a single logical entity. Atomicity is important when creating an API. When using atomicity, poorly naming a function is just a terrible idea.

When is atomicity needed?

Imagine we want a user to be created as an admin under the admins' group table. Still, we haven't yet created the admin group table, so our logic is to create a user as an admin, create the admin group table, then add the admin user to the admin group table.

But what if it fails? Let's say the user isn't created as an admin, but the admin table is created or vice versa. That is where atomicity comes in play.

When using atomicity to call an action, try to call the right action instead of a generic action. Otherwise it makes a massive mess of the API, and there will be confusion when using the API.

Implement Pagination

When creating a huge microservice and the response body or object becomes too large, pagination makes it easier for the API to return a small amount of information.

Pagination is a method of separating digital content into different pages on a website or a response object.

Imagine a database with seventy users. The API calls getUsers instead of sending the response of all the users at once and making it slow.

You can break the response down, like return the first thirty users, the subsequent thirty users, and the following ten users. The paginated response is faster, though.

But this violates the property of stateless APIs, which is when an external user handles the storing of session-related information on their end.

Use Fragmentation

When an API communicates internally, the response is usually short. But when it is a large response, it is an exception, and when it is an exception, there is a problem.

This occurs when the response surpasses its limit ( 10kb or 15kb per response). The solution here is to break the response down and give it to another service bit by bit.

It is like breaking the TCP (Transmission Control Protocol) number into fragments and giving it out so the service will not be overloaded.

It will know that more details are yet to come, and it will also have an end packet, like a break command, that says the protocol is ending when the fragments are about to end.

Conclusion

Here are some major takeaways from this article:

• Avoid strange character and use words that represent the contents of the API response.
• Pagination and fragmentation are essential when the response object is vast.
• You should cache your requests if you have a lot of load on your database.
• If you have a lot of load, reduce your response time instead of passing the full information to the user. Just pass in the essential or critical data. That is called service degradation. It involves giving the essentials and still responding without crashing the API service.
• When designing an API and you want a perfect data consistency, cache your responses.

Data scalability refers to the ability of a database to manipulate changing demands by adding and removing data. In this way, the database grows at the same pace as the software.

Via scaling, the database can expand or contract the capacity of the system's resources to support the application's frequently changing usage.

There are two ways a database can be scaled:

• Horizontal scaling (scale-out)
• Vertical scaling (scale-up)

In this article, we'll look at both methods of scaling and discuss the advantages and disadvantages of each to help you choose.

Horizontal Scaling

This scaling approach adds more database nodes to handle the increased workload. It decreases the load on the server rather than expanding the individual servers.

When you need more capacity, you can add more servers to the cluster. Another name for this scaling method is Scaling out.

Advantages of Horizontal Scaling:

• It is easy to upgrade
• It is simple to implement and costs less
• It offers flexible, scalable tools
• It has limitless scaling with unlimited addition of server instances
• Upgrading a horizontally scaled database is easy – just add a node to the server

Disadvantages of Horizontal Scaling:

• Any bugs in the code will become more complex to debug and understand
• The licensing fee is expensive as you will have more nodes that are licensed
• The cost of the data center will increase significantly because of the increased space, cooling, and power required

When to use horizontal scaling:

If you are dealing with more than a thousand users, it is best to use this scaling system because when the servers receive multiple user requests, everything will scale well.

It will also not crash because there are multiple servers.

Vertical Scaling

The vertical scaling approach increases the capacity of a single machine by increasing the resources in the same logical server. This involves adding resources like memory, storage, and processing power to existing software, enhancing its performance.

This is the traditional method of scaling a database. Another name for this approach is Scale-up.

Advantages of Vertical Scaling:

• The cost of the data center for the space, cooling, and power will be smaller
• It is a cost-efficient software
• It is easy to use and implement – the administrator can easily manage and maintain the software
• The resources for this approach are flexible

Disadvantages of Vertical Scaling:

• The cost may be low, but you will need to pay for a license each time you scale up
• The hardware costs more because of high-end servers
• There is a limit to the amount you can upgrade
• You are restricted to a single database vendor, and migration is challenging, or you may need to start over

When to use vertical scaling:

The vertical scaling approach is for you if you need a system with unique data consistency.

If you don't want to worry about balancing the server's workload, vertical scaling is the best option.

Differences Between Vertical and Horizontal Scaling

Which scaling method is best for your app?

When choosing how to scale your database, you must consider what's at stake when you scale up and out.

Now we'll take a look at some factors to consider so you can choose which scaling system is best for your app:

Load balancing

The vertical scaling system is best for balancing loads because you have a single server (vertical scaling), and there is no need to balance your load. Horizontal scaling requires you to balance the workload evenly.

Point of failure

The horizontal scaling system has more than one server, so when one server crashes, the next one picks up the slack. This means that there is no single point of failure which makes the system resilient.

But in the vertical scaling system, there is only one server, so once the server crashes, everything goes offline.

Speed

In terms of speed, the vertical scaling system is faster because, since it runs on one server, the vertical scaling system has an interprocess communication – that is, the server communicates within itself and it's fast.

The horizontal scaling system has network calls between two or more servers. This is also known as Remote Procedure Calls (RPC). RPCs are slow, though.

Data consistency

When dealing with servers, you'll need to make sure that the data stored in them is consistent when end users send a request.

The vertical scaling system is data consistent because all information is on a single server. But the horizontal scaling system is scaled out with multiple servers, so data consistency can be a huge issue.

Hardware limitations

The horizontal scaling system scales well because the number of servers you throw at a request is linear to the number of users in the database or server. The vertical scaling system, on the other hand, has a limitation because everything runs on a single server.

When choosing a system to scale your database, make sure to make a pros and cons list of the information in this article. It will help you decide which to use.

Conclusion

A cloud computing model's scalability is the ability to quickly and instantly increase or decrease an IT capacity. Knowing how the two types of scaling work is crucial as this plays a massive role in your database or server management.

Quick recap...

• A server's role is to enhance its capacity to handle the increased workload, called Vertical scaling.
• A system's job is to add new nodes to manage the distributed workload, termed Horizontal scaling.
• The horizontal scaling system scales well as the number of users increases.
• The vertical scaling system is faster due to its ability to inter-process communication.

Thanks for reading!