DEV Community: Ezekiel Lawson

5 Tips for Using Digital Avatars in Recruitment Videos

Ezekiel Lawson — Wed, 04 Dec 2024 09:51:39 +0000

Recruiting good-fit talent these days can be challenging and time-consuming. Traditional hiring methods often involve lengthy interview rounds, each with high costs and logistical hurdles. To streamline this process, companies are increasingly turning to video-based recruitment—and even taking it a step further with digital avatars.

Digital avatars offer a fresh, engaging approach to recruitment videos, enabling companies to create tailored, responsive interactions with potential hires. These AI avatars can handle initial candidate interactions, answer common questions, and give candidates a glimpse into company culture—without requiring live interactions at every stage. This frees up valuable time for hiring teams and offers candidates a better experience.

Many organizations, such as Dropbox, Starbucks, and GE Aerospace, have embraced video recruitment to showcase their work environments and core values. Integrating digital avatars can amplify these benefits, making recruitment faster, more accessible, and even more appealing to today’s top talent.

Since AI avatars are a relatively new technology, adopting them effectively requires strategy. This article will explore the top five tips to help you make the most of digital avatars in recruitment videos.

What is a Digital Avatar?

A digital avatar is a virtual character generated through AI that interacts with users in real time. Designed to resemble a realistic person or a stylized character, digital avatars are embedded with conversational abilities that make them suitable for interactive roles, like guiding candidates in recruitment videos.

They can welcome applicants, provide information about the company, and answer common questions, giving candidates a feel for the company without requiring live interaction.

The popularity of digital avatars is rising because they offer a flexible, scalable solution for candidate engagement. Instead of scheduling numerous initial calls, hiring teams can use avatars to interact with many candidates simultaneously, saving time and resources.

Additionally, digital avatars add a layer of personalization, giving candidates an engaging experience that stands out from traditional recruitment methods. This approach appeals to today’s tech-savvy candidates who value innovation and convenience in their job search.

Steps In Using Digital Avatars In Recruitment Videos

Our tutorial, "Turn Job Descriptions Into a Recruitment Video With AI," goes into transforming text-based job descriptions into interactive video interviews. By leveraging Simli’s API, you can set up a virtual interviewer that delivers pre-generated questions based on the job description, making it possible to handle multiple applicants simultaneously and reducing recruitment time from weeks to just a few days.

The tutorial covers all the necessary steps, including:

Setting up Simli and OpenAI accounts.
Configuring API keys to connect to these services.
Generating interview questions and audio responses using OpenAI’s chat completions and text-to-speech APIs.
Integrating Simli's API to generate a lip-synced AI avatar that presents questions to applicants.

Head to the complete tutorial for code samples and setup instructions to create your AI-driven recruitment video setup.

5 Tips for Using Digital Avatars in Recruitment Videos

Here are five practical steps to adopt this technology in your hiring videos.

1. Set Clear Objectives

Are you looking to create an engaging pre-interview, introduce candidates to your company culture, or evaluate specific competencies? Defining the purpose of your avatar-based recruitment videos is critical. For instance, if you’re aiming to screen for technical skills, outline what the avatar will communicate about the role and gather from candidates.

Specific objectives help shape the interview flow and question prompts, which can be tailored into concise, captivating segments delivered by the avatar. Without clear goals, the video may lack focus, affecting candidate engagement and data collection quality.

2. Choose the Right Avatar Personality

Selecting an avatar that aligns with your brand and the job role is key. A straightforward and professional avatar can convey the right tone for technical roles, whereas a more relaxed persona may be better suited for creative roles. Platforms like Simli offer a variety of avatars, and many tools allow for customization down to the voice.

Opt for avatars that fit the technical expectations of the role, ensuring they set the appropriate atmosphere and leave a positive impression on candidates. A misaligned avatar can disrupt the candidate experience and dilute your brand’s message.

3. Use AI to Generate Tailored Interview Questions

Automate interview questions with an AI tool like OpenAI's chat completions API. This approach lets you dynamically create questions based on a job description, making the interaction more personalized.

Feed the avatar prompts that match the technical and soft skills you're seeking, making certain the questions align with the real-world challenges of the role. This step can save time in interview preparation while providing candidates with an authentic glimpse into their potential responsibilities.

4. Integrate Lip-Synced Audio for Realistic Interactions

To create a natural feel in your videos, convert text-based questions to audio, then sync the audio with the avatar's lip movements using a platform like Simli. This process requires downsampling audio to 16kHz PCM to match typical WebRTC audio standards, which many tools automate.

Using lip-synced avatars allows candidates to experience a smoother, more lifelike conversation, making the interaction feel less automated and more engaging.

5. Test and Iterate Your Videos

Before launching avatar-led interviews, conduct tests with a diverse group to gather feedback. Watch for awkward pauses, audio misalignments, or unclear prompts, and refine the script based on real interactions. Regularly update the avatar content to reflect current job demands, company culture, and candidate feedback. This iterative process will make your video content relevant and polished, maintaining a professional edge that resonates with your ideal candidates.

Scale Recruitment Efforts With Cost-efficient Digital Avatars

Digital avatars are an accessible, budget-friendly way to scale recruitment. With tools like Simli, which offers pay-as-you-go pricing, you can keep costs low by paying only for what you use.

Simli’s AI Video Avatar platform enables developers to create avatars that mimic human movement and speech convincingly, adding a personal touch to recruitment videos that resonates with candidates.

Beyond hiring, Simli’s avatars can be adapted for employee interview practice, sales support, language lessons, and coaching, making it a versatile tool for various business needs.

Simli provides a demo page to explore character options and offers an open-source project that integrates with OpenAI, providing hands-on guidance for developers. Its starter project lets developers clone and experiment with a digital avatar setup quickly, with 60 free minutes of API use and no credit card requirement. This trial period offers a low-risk way to experiment with the technology before committing to further usage.

Conclusion

Digital avatars reduce the stress and time recruiters spend using traditional methods in employee interviews and cut the cost of hiring more recruiters. Tools like Simli make it easy for companies to add AI avatars to their hiring process in just a few clicks.

Simli has a Discord channel where you can connect with other members and ask questions about an issue you encounter with the tool, and learn more about maximizing its features.

Build an Appwrite database search dashboard with Algolia

Ezekiel Lawson — Thu, 18 Jan 2024 15:02:32 +0000

Crafting a compelling website search experience has historically posed certain challenges, causing pain points such as slow results and relevance problems as datasets expanded. However, Algolia has revolutionized this process. Its powerful API facilitates real-time data searches, solving speed, suggestion, relevance, and user experience concerns. Integrating Algolia guarantees fast and seamless search integration for websites and mobile applications. This article will show you how to build a database search dashboard with Appwrite and Algolia. You will use the built-in Appwrite Cloud Function template Sync with Algolia. Let’s get started!

Prerequisites

Before you proceed, you’ll need the following under your belt:

A GitHub account
Appwrite Cloud account
An Algolia account

Checkout the complete project on Github

Once you’ve got all the necessary requisites, we can begin creating an Appwrite Cloud Function template is the subsequent step. However, before delving into the setup process, let's take a moment to talk a bit about what an Algolia search engine is and what it offers.

First, what is Algolia? Algolia is a hosted search engine tool designed to empower businesses to optimize search and discovery speed while mitigating the challenges of relevance tuning through AI. This platform provides users with tools for tailoring their search experience, offering solutions that cater to various use cases. Algolia focuses on two key aspects: implementing search functionalities and comprehensive search analytics.

Setting up Appwrite Cloud Functions

The first step will begin by creating a new Appwrite project. Navigate to the Appwrite's Cloud console and select Create project. Creating a new project will give you access to the Appwrite Function, Project ID, and API key.

Following that, you will proceed to creating your Database and Collection. Copy the corresponding IDs and store them in a readily accessible location — you’ll need them during the creation of the Appwrite Function.

To create your database, navigate to the left menu bar and click on Databases.

The next step is to create a collection, like a container for a list of documents.

Click the Create button to initiate your new collection. Afterward, go to the side menu, select Functions, and click on Templates for the next steps.

Once you've finished the previous step, a list of available options will appear. Choose the template from this list that aligns with your project's requirements. You can use the search bar to quickly locate the specific template needed for this project, which, in my case, is Sync with Algolia. Next, click on the Create function button.

Next, select a Node.js runtime. Select 18.0 as the runtime in this example and click the Next button.

The subsequent step involves adding environment variables for your function's runtime. Appwrite requires seven variables, as illustrated in the example below. Click on the Generate API key option. Once created, this action will automatically create the APPWRITE_API_KEY for your project and apply it to this function.

Then, navigate to the location where you stored your APPWRITE_DATABASE_ID and APPWRITE_COLLECTION_ID. Copy the respective IDs and paste them into the right inputs.

Afterward, navigate to your Algolia website and copy the following ID shown in the diagram below.

To get the following IDs, you must create an account with Algolia, as stated in the prerequisites. Now’s the time to log into your account and navigate to where you have your account profile. Click on the dropdown icon and click on Settings. This will take you to the section where you can create a new application and the ID.

Create Algolia application and index

Afterward, you'll be prompted to choose a region. Upon selecting a region, you'll have to complete a ReCaptcha test, and that concludes the application creation process!

Following that, copy the ALGOLIA_APP_ID — the ID of the recently created application. To do so, return to the settings, under the Team and Access section, click on API Keys.

This will give you access to where you will find the ALGOLIA_ADMIN_API_KEY and ALGOLIA_SEARCH_API_KEY.

The last ID is the ALGOLIA_INDEX_ID, and this is the ID of the index in Algolia where the documents are to be synced. Return to the overview page and navigate to the left-side menu of the dashboard. Click on the menu Search.

Next, you’ll create an Index. This index is where you’ll import your Appwrite data. Click on the Create index button.

When creating an index, it is crucial to exercise great caution in spelling, as even a minor error in word choice can lead to an error in your project. Algolia guides you on naming your index appropriately, offering strategies to mitigate the risk of such errors.

You have now successfully created your index! The next step is to get your Index ID. Your Index ID corresponds to the name you assigned to the index during creation. Copy this Index ID and paste it into the required section that prompts for the index ID.

After creating your Index and Algolia Application, revisit the section where Appwrite initially requested the variables and paste the Algolia variables.

Next, connect the function to a new or existing repository within a selected Git organization.

Next, you will install Appwrite on your GitHub.

In the process of installing, Appwrite will request access to your GitHub.

After granting Appwrite access, you will be redirected to the Appwrite installation process. Click on the Repository option to see an automatically generated repository. Feel free to modify the repository name to align with your preferences. Remember that you can uncheck the Keep repository private checkbox if you prefer.

The final step in creating an Appwrite Function is to select your branch name. In this section, you can leave the branch name as main or choose a different name based on your preference.

Congratulations! You have successfully created your Appwrite Function for syncing with Algolia. Following the creation of your function, you can locate your Deployment ID, Domain, and GitHub source code, as illustrated in the diagram below.

You’re not quite done yet! The aim is to learn how to synchronize your Appwrite data with Algolia and subsequently query that data. Below is a screenshot of what your application should look like when you click on the Domains URL.

To get this synchronization going, begin by navigating to the Databases menu. Click on the specific database you created to be redirected to the associated Collections. Within the collection, you will be directed to the Documents page. Click on the button create attribute to add and organize your data.

You will notice four options for the attribute type you intend to create. Choose String, as that's the first attribute type you will be working with.

You will create a data collection for a phone, focusing on three key pieces of information: Brand, Model, and Price. Next, add the attribute key and size. Tick the Required box if you want to make the string required.

Proceed to create the remaining two attributes, model and price. Below is an image illustrating the expected structure of the three attributes.

To proceed, update the attributes with the correct data. Navigate to the Documents menu and click the Create document button.

Next, choose the individuals who should access your documents and collections. Once you have configured the access settings, click the create button to complete the process.

You have now updated your attributes with the correct data — and you are getting closer to finishing up! The next step is to index the data in Algolia. To accomplish this, navigate to your Function template and click the Execute Now button. A modal will appear, prompting you to execute your function manually. Leave the path unchanged and switch the method from GET to POST. After making this adjustment, click the Execute button to initiate the indexing process.

After your function has been successfully executed, there's one more step. Verify the log to ensure that your data was synchronized with Algolia. Click on the Execution ID, leading you to the Logs input for a detailed examination.

The next step is to confirm the data in the Algolia index. Head to the Algolia dashboard and refresh it; you will observe the new data you added to Appwrite.

Now that you have confirmed that your Appwrite data has been successfully indexed in Algolia, the next step is to query the data using the search input. As you have seen, the Appwrite Cloud Function template seamlessly integrates with Algolia, offering developers flexibility in synchronizing data. In the Algolia dashboard, you can configure which attributes are irrelevant or have higher priority and sync the parameters you need, as seen in the customization option below.

Customization with Appwrite and Algolia

The Appwrite and Algolia template allows you to customize and synchronize your required parameters. For example, suppose you only need three parameters: the phone's brand, model, and price. In that case, you can achieve this by accessing the index.html file and replacing the existing code within the script tag in the index.html file with the provided code below to change how data is displayed in the demo.


       const algolia = algoliasearch(
            '{{ALGOLIA_APP_ID}}',
            '{{ALGOLIA_SEARCH_API_KEY}}'
          );

          const search = instantsearch({
            indexName: '{{ALGOLIA_INDEX_ID}}',
            searchClient: algolia,
          });

          const searchBox = instantsearch.widgets.searchBox({
            container: '#searchbox',
          });

        const hits = instantsearch.widgets.hits({
          container: '#hits',
          templates: {
            item(hit, { html, components }) {
              return html`
                <div class="card">
                  <div class="card-body">
                    <h5 class="card-title">${hit.brand}</h5>
                    <p class="card-text">${hit.model}</p>
                      <p class="card-text">${hit.Price}</p>
                    <!-- Add other properties as needed -->
                  </div>
                </div>
              `;
            },
          },
        });

        search.addWidgets([searchBox, hits]);
        search.start();

Demo

Conclusion

Congrats! You’ve created a robust database search dashboard by leveraging the combination of Appwrite and Algolia. Using the Appwrite Cloud Function template for sync with Algolia, you can now incorporate an efficient search solution into your websites.

Resources

Keep your online community safe: Build automated message moderation with Appwrite Cloud Functions

Ezekiel Lawson — Wed, 06 Dec 2023 11:07:13 +0000

Maintaining a safe and welcoming environment is a priority in today's online communities. Regardless of the type of online community we manage, be it a social platform or discussion forum, ensuring the security and protection of users from harmful or inappropriate content is a necessity. With the help of Appwrite Cloud Function template Analyze with PerspectiveAPI, we can build an automated message moderation system that allows community managers and developers to protect their online spaces against hate speech and unhelpful criticism.

In this tutorial, you’ll learn how to create an automated message moderation system to promote a friendlier and more constructive online atmosphere. To do so, we’ll use Appwrite Cloud Functions and integrate the "Analyze with PerspectiveAPI" template. Additionally, we will discuss customization options for how to tailor the message rules better to suit our community's unique needs.

Prerequisites

You’ll need a few things before getting started:

A Google account.
A working Appwrite account. Don’t have an account? Create one on the Appwrite website.
An API key from the PerspectiveAPI website.

Setting up Appwrite Cloud Functions

If you’ve got the prerequisites covered, the next phase involves setting up an Appwrite Cloud Function. However, before we delve into the setup process, let's first take a moment to understand an Appwrite Cloud Function.

Appwrite Function s are serverless functions that empower us to write custom code and perform specific tasks responding to various triggers, such as HTTP requests or scheduled events. Running this code on the server side increases the functionalities of our application. This versatility makes it an effective tool for data processing, integrating third-party services, and automation.

Appwrite Functions give us the power to create almost anything we can think of. Sometimes, it can be hard to figure out where to start — thus, the gift of a function template. Our first step will begin by creating a new Appwrite project. Log in to Appwrite’s cloud console and select Create project. Next let’s create a new project, which will give us access to the Appwrite Function and other services like our Project ID and API key.

Click on the Create button, and the project will be created successfully. The next step is to create our Appwrite Function. To do that, navigate to the side menu and click on Functions. Next, click on the Create function.

When you clicked the Create function button, you likely noticed that Appwrite Functions offered quick-start templates for us to begin with. If we can't find the specific template we need, then we can access additional templates by clicking on the All templates option.

After completing that step, a list of available options will be displayed. From this list, select the desired template, which, in this instance, is Analyze with PerspectiveAPI. There are two methods to access the templates: using the search bar or scrolling to locate the desired template. In this case, we will utilize the search bar. To proceed, search for the template name and click Create function to select it.

Select Node.js - 18.0 as the runtime.

The next part is adding a variable called the PERSPECTIVE_API_KEY. This key is available only from the PerspectiveAPI website. (You’ll remember this from the prequisites.)

Once we insert our API key, it will take us to the next phase of linking our Function to either a new repository or an existing one in a chosen Git organization. Choose the Create a new repository option.

Next, choose a Git repository to activate our function deployments upon updates. At present, GitHub is the only available Git repository option; others are still in development.

After choosing a Git provider, the next step will prompt us to grant Appwrite permission to access our GitHub account.

After we have given Appwrite access, it will lead us to Appwrite for further installation. Click on the Repository option, and we will notice an automatically created repository. The repository name can be modified to match your preferences. Remember, we can choose to deselect the Keep repository private checkbox.

The next step is to select our branch name. In this section, we can leave the branch name as the main.

We have effectively created an Appwrite Function. Below is a deployment diagram illustrating the ID, Build time, Size, and Domain.

Demo integration with PerspectiveAPI

We've completed the creation of our Appwrite Function and successfully configured our PerspectiveAPI! Next, let’s take a look at the integration and demonstrate how the PerspectiveAPI filters toxic speech. See the code below of what our Appwrite function code will look like in the main.js file.


   import { fetch } from 'undici';
    import { getStaticFile, throwIfMissing } from './utils.js';

    export default async ({ req, res }) => {
      throwIfMissing(process.env, ['PERSPECTIVE_API_KEY']);

      if (req.method === 'GET') {
        return res.send(getStaticFile('index.html'), 200, {
          'Content-Type': 'text/html; charset=utf-8',
        });
      }

      try {
        throwIfMissing(req.body, ['text']);
      } catch (err) {
        return res.json({ ok: false, error: err.message }, 400);
      }

      const response = await fetch(
        `https://commentanalyzer.googleapis.com/v1alpha1/comments:analyze?key=${process.env.PERSPECTIVE_API_KEY}`,
        {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            comment: {
              text: req.body.text,
              type: 'PLAIN_TEXT',
            },
            languages: ['en'],
            requestedAttributes: {
              TOXICITY: {},
            },
          }),
        }
      );

      if (response.status !== 200) {
        return res.json(
          { ok: false, error: 'Error fetching from perspective API' },
          500
        );
      }

      const data = /** @type {*} */ (await response.json());
      const score = data.attributeScores.TOXICITY.summaryScore.value;
      if (!score) {
        return res.json(
          { ok: false, error: 'Error fetching from perspective API' },
          500
        );
      }
      return res.json({ ok: true, score });
    };

The code above is where we modify our changes. After making changes and committing them to the file, Appwrite will seamlessly redeploy our function automatically, as seen in the diagram below.

To see a live demonstration of our project, navigate to the deployment section in the Appwrite console. You will also find the ID, Build time, and Size there. Click on the generated Domain. This live demonstration highlights PerspectiveAPI's functionality, displaying how it evaluates the toxicity score of the message.

Customization option for message moderation

Appwrite allows us to customize and moderate messages to fit our specific requirements. In this segment, we will create a comment section within the blog. Here, we will adjust the toxicity threshold based on a percentage to effectively filter out toxic comments, enabling us to decide which comments to display and which to withhold from the view. To accomplish this, replace the existing code within the script tag in the index.html file with the provided code below:

        async function onSubmit(text) {
          const response = await fetch('/', {
            method: 'POST',
            body: JSON.stringify({ text }),
            headers: {
              'Content-Type': 'application/json',
            },
          });

          const data = await response.json();

          if (!data.ok || data.error) {
            alert(data.error);
          }

          const percent = Math.round(data.score * 100 * 100) / 100;

          if (percent > 80) { 
            return 'Toxic comment hidden';
          } else {
            return `Toxicity of your message is: ${percent}%`;
          }
        }

View the outcome of the customized feature we implemented, designed to conceal toxic comments from public view.

In the preceding section, we implemented a feature for enabling users to add comments to the blog, assessing the comment's toxicity, and concealing it from public view. This functionality has effectively allowed us to filter out toxic comments and hate speech from our platform. The Appwrite Cloud Function templates offer significant advantages by providing pre-built integrations, enabling us to implement additional features. This significantly reduces the burden of building from scratch and speeds up the development process.

Another customization option is to store toxic comments in an Appwrite Cloud Database. This allows us to track the total number of toxic comments from a user and, if needed, implement measures like banning the user from using the platform.

Conclusion

This article elaborated on moderating messages and maintaining online community safety using Appwrite Cloud Functions and its template Analyze with PerspectiveAPI. We also covered customization options and provided an implemented example.

Resources

5 ways Appwrite Cloud helps freelancers handle more clients with ease

Ezekiel Lawson — Wed, 09 Aug 2023 11:02:06 +0000

The global market for freelancing is expected to be valued at $1.5 trillion and is growing at a compound annual growth rate (CAGR) of 15%, according to reports and freelance statistics. As of 2023, there were approximately 1.57 billion freelancers worldwide, and that figure is anticipated to rise even further in the ensuing year. As their client base expands, freelancers seek new tools and technology to improve productivity and handle multiple clients more effectively. With the help of Appwrite Cloud's extensive features, you can easily handle additional clients. In this article, you will learn five ways freelancers can use Appwrite Cloud to handle more clients easily.

Challenges freelancers face in managing multiple clients

Managing several clients as a freelancer can be both lucrative and challenging. Although it provides the ability to work on various projects and boost your income, it also presents several difficulties.

Poor tools or technology
Finding the right tools to deliver to clients is a difficult problem for a freelancer. Using the incorrect technology to handle a client project can result in unexpected technical problems. These problems include network outages, hardware failures, software faults, data loss, and compatibility challenges. All of these can cause workflow disruptions and delays in completing customer work. These difficulties can be time-consuming and frustrating for both you and your clients.

Acquiring new skills and knowledge
You might have to use tools or technology you are unfamiliar with as a freelancer. This can create a new learning curve for you while also contending with tight deadlines. This could delay completing the client's work, as you must learn how to use the new tool(s) and gather materials before becoming sufficiently effective.

Integrating and combining software
Another significant challenge is integrating numerous software systems and technologies that one’s clients might utilize. Ensuring compatibility between many platforms and data formats may demand additional effort and result in debugging. This difficulty occurs when clients have a specialized system or when you need to synchronize data across many tools.

Security
Security is a major concern when handling multiple clients, as it involves securely handling sensitive data, including financial and personal information. This can be done by implementing strong security measures, including data encryption, secure file exchange, and strict access limits.

Scaling freelance businesses and managing multiple clients with Appwrite Cloud

Expanding a freelance business is a challenging task made less complex by leveraging cloud-based services like Appwrite. Appwrite is an open-source and self-hosted backend as a service (BaaS) tool that manages the core backend needs. It provides easy-to-use Rest APIs and abstracts the complexity and repetitiveness required to build a modern backend API from scratch, allowing developers to build faster and more secure apps.

Appwrite developed a cloud-based version, Appwrite Cloud . This product alleviates the tension associated with hosting an Appwrite project in the cloud, providing developers with various tools and services that handle the various backend tasks. Consequently, you can concentrate more on development than managing infrastructure.

Aside from that, it provides key features and services that can help you focus on building high-quality applications and delivering robust, scalable solutions to your clients. Here is how Appwrite Cloud can help you scale freelance businesses and handle more clients with ease:

1.Centralized client data

One of the concerns you will face when managing clients is data centralization. With Appwrite Cloud, you can store and manage client data in one place with the managed database solution. This simplifies accessing client information and project histories, enabling superior client base management.

When working with clients, organizing and maintaining all client information for simple access can be challenging. With Appwrite Cloud Console, you can manage customer information. You can also store project histories by keeping track of all the work you have completed for each client.

2.Good backend infrastructure

Appwrite Cloud provides a scalable backend infrastructure that helps you focus more on your development without worrying about managing servers or infrastructure. It automatically manages server upkeep, upgrades, and scalability, allowing you to scale your applications easily as your client base grows.

Being in charge of all the server-side functionalities makes it difficult to create a backend infrastructure for an application. With Appwrite Cloud, however, all server-side functionality is taken care of, allowing you to concentrate on development rather than worrying about storage, hosting, server management, and other issues.

3.Secured data and privacy

Security becomes more difficult as your clientele grows, as strong and scalable security measures or tools must be deployed to help protect client data. Appwrite Cloud provides robust security measures such as data encryption, encrypted connections, and access controls. With these measures, you can manage clients’ credentials, control user permissions, ensure data privacy within your application, and build client trust.

The Appwrite operations team also conducts routine security updates on third-party tools. It keeps track of security issues because most third-party tools have security holes that can lead to data breaches in your application and put the privacy of your clients at risk. Because of this, they offer various monitoring options to prevent and mitigate attacks on the platform.

4.Custom integration system

A unique feature when using Appwrite Cloud as a freelancer is that you can customize your integration with the third-party services and APIs Appwrite Cloud provides. You can also connect your favorite technology or external tools to your application. It allows seamless integrations such as payment gateways, email marketing platforms, and other tools that improve client base management. Below is a list of some popular technologies you can integrate with Appwrite.

Appwrite Cloud provides all of the capabilities mentioned above to assist you in overcoming the difficulties of managing multiple clients. Even though Appwrite is a fantastic tool for expanding your freelancing work, it has certain drawbacks. The constraints and requirements of the specific project must be carefully considered before choosing Appwrite as a freelancer.

Conclusion

The Appwrite Cloud is a fantastic solution for managing and handling freelance work, as it enables you to overcome all of the procedures that drive up project expenses and cause delays. It provides various services to help you overcome the difficulties covered in this post and expand your client base.

Resources

Build fast with Appwrite Cloud
Follow the Dev.to page to find more resources on how to get started with Appwrite as a freelancer
Join the Appwrite community to meet other developers and solve problems

How Appwrite's database relationships can supercharge your mobile app development

Ezekiel Lawson — Fri, 16 Jun 2023 12:47:05 +0000

The development of our mobile applications heavily relies on the relationships within the database because they reduce the repetition of data in our existing tables. Additionally, it decreases the volume of transactions while enhancing data integrity because joins, searches, and data sorting become a high cost as our data grows. With the Appwrite database relationship, we can enhance the functionality and efficiency of our mobile app development as it allows us to quickly establish connections between different pieces of data in our database.

In this article, we will learn how the Appwrite database can supercharge our mobile app development, the benefits, and best practices for using Appwrite's database relationship.

Benefits of using Appwrite's database relationships

The database relationships offered by Appwrite offer a robust and convenient solution to manage data in creating our mobile applications. In addition, we can develop advanced apps with tons of features. Using Appwrite's database relationship has additional advantages, some of which include the following.

Data handling made easier: the Appwrite Database relationship allows us to easily link and recover data from different collections in our database; this simplifies the process and reduces the time used to manage and manipulate data.
Increased effectiveness: With database relationships, we can avoid having to run several queries or join tables, which can enhance the speed and effectiveness of our app by merely lowering the amount of data repeated.
Extensibility: Appwrite's database relationships are designed to be extensible, allowing us to handle a large amount of data and traffic as our app grows and evolves. It encourages a systematic approach to managing our data.
Flexibility: The Appwrite NoSQL document-based database provides a flexible and schema-less approach to data modelling. This can be particularly useful when dealing with complex and evolving data structures.

How Appwrite's database relationships work

Appwrite is an open-source backend server that provides us with tools and services for creating web and mobile applications. Its database module allows us to store and manage our data securely. One of the distinctive benefits of utilizing the Appwrite database module is the ability to define relationships between different collections.

Appwrite database relationships simplify building complex applications that require data stored in multiple collections. By defining relationships between collections, we can create an integrated data model that enables flexible data retrieval and manipulation.

Appwrite's database schema is built around the concept of collections and documents. A collection is a set of connected documents equivalent to a table in a conventional relational database. Each document in this collection is a JSON object that includes information about a particular item in the collection.

To model data in Appwrite, we must define the structure of each document using a JSON Schema, which is a great format for describing the shape and content of JSON data. This allows us to define the type of data stored in each field and any validation policy or restrictions that should be applied to the data. It also supports various indexing and querying features, allowing us to retrieve data based on multiple criteria quickly. For example, we can create indexes of unspecific fields to speed up queries that filter or sort data based on those fields.

There are types of database relationships available in Appwrite:

One-to-one relationship: This relationship is the simplest to describe in databases because each record in one collection is connected with one and only one form in another collection, and vice versa. Each profile is unique and represents a single identity in a one-to-one relationship.
One-to-many relationship: A relationship between two data collections, where one item from one collection is connected to many items in another. Consider a blog post with comments in each post. In this case, the connection between the blog post collection and comments collection would be one-to-many.
Many-to-one relationship refers to a relationship between two collections in which numerous records in one collection can be linked with a single record in another collection. This type of relationship is commonly used when there is a need to link data between two entities in a database.
Many-to-many relationship: In a many-to-many relationship, a single record in one collection can be linked to several records in another collection and vice versa. For instance, think of a school database where students can enroll for multiple courses, and each of those courses can have multiple students.

By understanding these relationship types, we can choose the one that suits our application's needs and build an efficient database management system.

Best practices for using Appwrite's database relationships

While Appwrite database relationships are a powerful feature that allows us to create relationships between different collections in our database, there are certain practices we must follow to ensure that our data is well-organized and easy to query:

Data model planning: When building our database relationship, it is necessary that we plan our data model carefully. We can plan our data model by identifying the business requirement, understanding the data that must be saved, used and consumed, and then defining the objects that will be included in the data model, creating database relationships and refining and documenting the data mode. All this will help ensure that our data is organized to fit our app and that we use the right types of relationships.
Understand and differentiate the Types of Relationships: Appwrite offers various types of relationships, as listed and explained in the previous section. We must carefully differentiate the different data types and choose the one that suits our application needs.
Integrate Appwrite's Built-in Methods: Appwrite provides us with various built-in methods to create and manage relationships, including createDocument and updateDocument. If you prefer not to manage your relationship manually, use this method.
Use IDs to create Relationships: We should use the ID of the related document and not the data types of values when creating a relationship. This method will help ensure that the relationships are accurately created and managed. This can simplify the process of updating or deleting related documents.

Use Cases for Appwrite's Database Relationships

The database relationship offered by Appwrite has a wide range of applications. Consider a school or online learning platform as one of the use cases. We can establish two collections in these contexts by employing the one-to-many relationship. There are a few to mention which are:

Social networking app
E-commerce website
Project management board
Blog post

The Appwrite database relationship has a wide range of additional applications, so it's important to understand them all and choose the one that best fits our needs.

Conclusion

Appwrite's database relationships can potentially revolutionize the creation of mobile apps. Appwrite can handle a variety of uses causes and helps us build powerful mobile apps. The Appwrite database relationship can assist us in streamlining our data administration and ensuring the seamless operation of our app. Using Appwrite's database relationships will help to advance our mobile app.

Resources

Here are a few resources to help us get started with the Appwrite relationship database

Learn more about the Appwrite database with the 30daysofappwrite article
Simplify your data management with these Appwrite resources
Understanding Database Relationship Types & How They Are Established

Breaking Through Growth Barriers: How Appwrite's Cloud Enables Scalability

Ezekiel Lawson — Thu, 27 Apr 2023 13:53:31 +0000

As businesses expand, our customer base grows with this. We often encounter growth barriers that can impede our development. One of the biggest challenges is scalability - handling increased demand without sacrificing performance or quality. This is particularly true for businesses that rely on software applications to deliver their products or services.

Thankfully, the development of cloud computing has given us access to strong technologies that can aid in overcoming these growth constraints. This article will examine how scalability is made possible by Appwrite's cloud and how we can use this platform to hasten their growth. We will discuss the features and advantages of using Appwrite cloud services.

Understanding Growth Barriers In Cloud Computing

Growth barriers in cloud computing are the challenges and obstacles we face when expanding our cloud computing services. The ability of cloud computing to handle rising workloads, users, or resource demands is hampered by several growth obstacles, some of which can be technological, operational, or non-technical issues. Some of these growth barriers consist of the following:

Expenditure: When we utilize cloud computing more regularly, the cost to manage it rises. This can be caused by more data storage, higher bandwidth usage, and the requirement for more powerful processing efficiency. This problem will force us to increase our security spending and ensure we follow auditing guidelines.
Integration: Integration is another great factor that hinders development because integrating cloud services with existing systems and applications can be complex. Making sure that integration is seamless gets harder for us as our cloud usage increases.
Performance and Scalability: As our cloud usage increases, maintaining excellent performance and capacity may become more challenging due to the need to invest in new infrastructure to manage rising demand.
Security and compliance: With the growing amount of data being processed and housed in the cloud, security and compliance issues are becoming increasingly crucial. We might need to spend more on security measures and ensure we adhere to legal standards.

Overcoming Growth Barriers with Appwrite's Cloud

Overcoming these barriers can be challenging, but with the help of tools, we can address the challenges associated with growth enabling us to scale our operations effectively and efficiently. One of the tools that can help us to scale our development is Appwrite. Appwrite is a cloud-based backend-as-a-service platform which helps to overcome growth barriers. Aside from that, it offers other great features and services that can help us scale those barriers we face when using cloud computing services. Some of which are:

Scalability

Appwrite’s Cloud is scalable; it can accommodate increasing demands as our application develops. It has the ability to automatically scale resources up or down in response to demand, ensuring that during times of high traffic, our application is always performing and responsive.

Time and Cost

With Appwrite pre-built backend modules and APIs, we can save time and money by reducing the need to build custom backend infrastructure from scratch. This could facilitate a quicker and more affordable launch of our application. One unique advantage is that we pay for the services we use. This can reduce expenses and erect a proper infrastructure.

Management of Data and Integration

Working with a cloud service requires us to consider integration. With Appwrite cloud, we can easily integrate other services without breaking the application status. Appwrite provides a scalable database that can handle large amounts and millions of requests per second. This means our application will be able to manage a large user base without any issues.

Performance

Appwrite’s cloud leverages on powerful hardware and infrastructure to deliver fast and reliable performance to our users. Appwrite’s platform is optimized for high-performance computing and can handle complex workloads easily.

Appwrite's Cloud: Features and Benefits

Appwrite cloud is an open-source platform that enables us to create and maintain backend services for web and mobile applications with its loud services; it provides more capabilities and advantages. The benefits and features of Appwrite cloud include the following:

Scalable Database

Appwrite’s Cloud offers a scalable database to query, save, and manage large data sets. The database is designed to be flexible and can handle any data, which makes it very easy for us to manage our application's data effectively.

File Storage

Appwrite’s cloud provides secure file storage for our applications, supporting file uploads, downloads, and management. It provides a built-in capacity to reduce and encrypt files, but this is only for smaller files.

Global Coverage

The fact that Appwrite's cloud service is hosted on a global network of servers ensures excellent performance regardless of where our users are located. Based on the location of our users, we may additionally modify the Appwrite Location API.

Easy Integration

We can extend Appwrite’s functionality using our favorite framework language (React, Angular, Vue, etc.) with serverless functions that scale on demand without the need to manage servers or infrastructure.

Secure Hosting

We no longer need to run our servers because Appwrite’s cloud service provides safe and scalable hosting for our backend services.

Custom Domain

With Appwrite cloud, we can now attach our domain to the Appwrite server using the new custom domain features. This enables us to employ first-party secure session cookies instead of third-party ones for web integrations and provides additional security and privacy protection. Also, this will facilitate the blocking of third-party cookies by modern browsers in the coming version.

Security & Privacy

Appwrite provides an integrated SSL certificate and encryption that keeps information private between our app and users, stops bad actors from abusing our app, and maintains an account of when and how information was accessed. It provides role-based access control, which means only users with specific roles may access particular areas of our application, ensuring the safety and security of our application and users' data.

How Appwrite's Cloud Enables Scalability

Appwrite’s cloud platform provides a scalable infrastructure that efficiently handles growing demand. Using the features below will ensure that our infrastructure can expand to accommodate them and always operate at its best.

Load Balancing: Appwrite's cloud platform provides load-balancing features that help distribute incoming traffic across multiple servers. This helps to ensure that the infrastructure can handle high levels of traffic and no single server becomes overwhelmed.
Auto-Scaling: The autoscaling capabilities of Appwrite allow it to modify the infrastructure resources to meet the current demand automatically. By doing this, our businesses can grow or shrink rapidly and effectively without manual processes.
Deployment Across Multiple Regions: We can deploy our infrastructure in several regions with the help of Appwrite’s cloud multi-region deployment capability. This offers redundancy and guarantees that our business can handle traffic from several regions without experiencing performance reduction.

Conclusion

For businesses that need to overcome expansion constraints and achieve scalability, Appwrite’s cloud is a great option. Appwrite can assist businesses of all sizes in streamlining their development process and scaling their operations to meet the demands of a rising user base thanks to its adaptable design and strong features. Hopefully, this article will help to overcome growth barriers using Appwrite cloud services.

Resources

Here are some helpful resources to get started with Appwrite:

Appwrite Git H ub repositories - Appwrite cloud service
Join the Discord community to ask questions and also learn more about Appwrite

GraphQL APIs and the Future of Front-End Development

Ezekiel Lawson — Thu, 02 Mar 2023 10:37:18 +0000

GraphQL is a powerful query language and runtime that enables developers to create efficient and flexible APIs. Its popularity among developers has risen due to its ability to handle complex queries and provide improved user experiences. As the future of front-end development is heavily influenced by how we consume and utilize APIs, GraphQL is expected to play a significant role in shaping it.
In this article, we will learn about GraphQL, its benefits, its impact on the future of front-end development, and how it works with Appwrite's API protocol through a code example.

Prerequisites

To follow this article, we need the following:

Prior knowledge of Vue and project installed on our local machine
Docker installed on our machine to check the version of our Docker, we will use the command docker --version. If Docker is not installed, we can install it from Docker documentation. Click this link for a better explanation of how to install it on macOS.
A running Appwrite instance (check out this article to create a local Appwrite instance)
Tailwind CSS installed in our Vue project

What is GraphQL?

GraphQL is a query language and runtime for creating and executing API queries. It was created by the Facebook team in 2012 and was open-sourced in 2015. It provides the schema of the Data in the API and allows users to specify the required data structure they need and the server will only return the requested data. This can decrease the amount of data transmitted over the network and make working with APIs with complex data schemas, much easier.

A Critical Appraisal of GraphQL

One of GraphQL's advantages is its adaptability. Clients can specify exactly the data they require in a single request, making it more efficient than a REST API, which may require multiple requests to different endpoints to gather the same information. Furthermore, GraphQL supports real-time updates and subscriptions, which enables developers to create dynamic and responsive applications. Additionally, its ability to handle complex relationships is an invaluable asset as it allows nested queries, which brings the possibility of retrieving related data in one request.

Advantages of using GraphQL

GraphQL is an increasingly popular API for front-end development that offers a variety of advantages, such as:

Improved Performance

GraphQL increases our application performance by reducing the number of queries and providing us with the data we need.

Better Development Tool

GraphQL provides developers with different tools that make development and debugging easier. We can also test our GraphQL applications with those tools; some of the tools are GraphiQL, Apollo Studio, etc.

Strong Type System

GraphQL provides a strong data typing system, better documentation, and simpler tooling.

Easy Integration and Maintenance

GraphQL is simple to integrate into existing systems, allowing us to start using it immediately without significantly modifying our current infrastructure.

GraphQL vs Rest API

GraphQL and REST are the most widely used architectural patterns for developing web services. While they have some similarities, they also have significant differences that must be considered when deciding between them.

GraphQL is a manipulation language for interacting with an API that retrieves data from a server or database and displays it in our application. With GraphQL, we can specify the data we need and the server will return only the requested data, which makes development easier and more flexible than Rest API.

GraphQL is schema-based, meaning we strictly define what goes to the server and what can leave the server. The schema is a compelling security point of view.

Rest API
REST API is a software architecture method for creating web services. It outlines a collection of restrictions and specifications for building web services used to communicate with other systems and web applications over HTTP. It manipulates resources via HTTP methods, including GET, POST, PUT, DELETE, and returns JSON or XML data.

Here are other side-by-side comparisons of GraphQL and Rest

GraphQL	Rest
It has a single endpoint (post/graphql)	Rest has multiple endpoints (POST/form, GET/user)
GraphQL reduces the number of necessary API calls to ensure we get the right amount of data; this helps improve application performance	It has slow performance due to under-fetching data, and unnecessary API calls
It is client driven	It is server-driven
It lacks an automatic caching mechanism and instead uses a library that is built on top of it	It uses caching automatically without any library
GraphQL complicates the handling of HTTP status codes to identify errors	Rest is easy to debug because it uses HTTP status codes to identify errors easily
It has a built-in meta validation	The validation is implemented manually

Finally, when deciding between GraphQL and REST for web services, developers should consider the type of application and data access requirements. If a large amount of data must be retrieved and updated in real time, GraphQL is the best option. However, if a simple, read-only application is being developed, REST is the better choice.

Limitations of GraphQL
While GraphQL is an efficient query language that simplifies the process of obtaining data from an API, it does have certain limitations.

GraphQL makes it challenging to create complex queries that require data from multiple sources or relational databases.
It cannot be used to access data outside of the API, making it less suitable for applications that require external data sources.
GraphQL does not provide built-in security features; as developers, we must implement our authentication and authorization mechanisms to secure our GraphQL API.
Error handling is complicated in GraphQL since it doesn’t use HTTP status codes like REST API.

Future of GraphQL API in Front-End Development

The GraphQL API has a promising future in front-end programming. Due to its capacity to manage various data sources, reduce data over- or under-fetching, and make optimal use of network bandwidth, it is anticipated to grow in popularity. The availability of more APIs means the development process is getting quicker and more effective. One is the capacity to query many databases with a single query effectively.

We can use GraphQL to create and maintain robust applications in our various languages and frameworks, including React, Angular, Vue, and Node.js.

GraphQL is essential to backend-for-frontend architecture because it allows clients to request the data they require, enabling developers to create backends specifically designed to meet the requirements of frontends like web apps. It offers a reliable and adaptable method to manage a data relationship, which can simplify the implementation of challenging BFF features.

Powering GraphQL with Appwrite's API Protocol

By integrating the Appwrite API server with our GraphQL API, we can leverage Appwrite's API protocol to power our GraphQL implementation. This integration also enables using Appwrite's administration tools for authentication, authorization, rate limiting, and logging to manage and secure our GraphQL API. The API protocol provided by Appwrite also enables the development of unique APIs to access data from other services. For instance, developers can create an API that we can use to retrieve data from a third-party database. It also offers a unified API gateway to gather and manage numerous APIs, including our GraphQL API, in one location.

Example of Using Appwrite with GraphQL

We will learn how to utilize Appwrite with GraphQL in this example; however, before moving on to the next step, there are a few things we need to understand and set up. All of the prerequisites are stated in the prerequisites section.

If all the requirements have been completed, let's create a new Appwrite project. Using the Appwrite Locale API, we will create a simple app that displays a country's currency symbol, name, plural, and decimal digits for all major and minor currencies.

Creating a New Appwrite Project

After creating our locale Appwrite instance and creating an account with Appwrite, we will be redirected to a page to create a new project:

In this section, we will name our project currency-app when we click on the “Create project” button, we will be redirected to our dashboard.

Appwrite SDKs make it easier to add any platform we want to use; for instance, we have the Web App, Flutter App, Apple App, and Andriod App. Select the Web App platform since we are building for the web:

When we click on the Web App platform, we will be redirected to a page to register our web app:

The next step is to get the Appwrite SDK we can choose our preferred method of adding Appwrite to our project:

To install Appwrite in our Vue project, use the command below:



    npm install appwrite

After installing Appwrite, the next step is to configure our Appwrite web SDK:



  const client = new Client();

    client
        .setEndpoint('http://localhost:90/v1')
        .setProject('PROJECT ID');

Go to the project overview in the Appwrite console and click on settings to get the project ID.

We can also get the project ID when creating a new web project in Appwrite; see the example below.

Creating Application Layout

The next step after installing and configuring Appwrite is to construct our application layout, which is where we will display the currency data we are collecting from the API.


 html

<template>
  <main>
    <section class="banner-image">
    </section>
    <section class="text-gray-600 body-font">
      <div class="container px-5 py-16 mx-auto">
        <div class="flex flex-col text-center w-full mb-20">
          <h2 class="text-xs text-indigo-500 tracking-widest font-medium title-font mb-1">Currency Application</h2>
          <h1 class="sm:text-3xl text-3xl font-bold title-font text-gray-900">List of Country Currencies and Symbols
          </h1>
        </div>
        <div class="flex flex-wrap -m-4">
          <div v-for="(currency, index) in currencies" :key="index" class="p-4 md:w-1/3">
            <div class="flex rounded-lg h-full bg-gray-100 p-8 flex-col">
              <div class="flex items-center mb-3">
                <div
                  class="w-16 h-16 mr-3 inline-flex items-center justify-center text-gray-800 border border-gray-800 bg-white flex-shrink-0">
                  <p class="text-black text-2xl">{{ currency.symbol }}</p>
                </div>
                <h2 class="text-gray-900 text-lg title-font font-medium">{{ currency.name }}</h2>
              </div>
              <div class="flex-grow">
                <h2 class="text-gray-900 text-lg font-bold">{{ currency.name }}</h2>
              </div>
            </div>
          </div>

        </div>
      </div>
    </section>
  </main>
</template>

The following step is to import the Client and GraphQL classes into our application. CurrencyApp.vue from the Appwrite library. This will enable us to leverage GraphQL capabilities from Appwrite in our web application:



    <script>
    import { Client, Graphql } from "appwrite";
    const client = new Client();
    client
      .setEndpoint('http://localhost:90/v1')
      .setProject('PROJECT ID');
    const graphql = new Graphql(client);
    export default {
      name: "CurrencyApp",
    </script>

Fetching the Currencies from Appwrite Locale API

In the following example, we create a data property that returns the list of currencies and then create a GraphQL query in our Vue component to get the Appwrite Locale API's list of currencies:



  <script>
    import { Client, Graphql } from "appwrite";
    const client = new Client();
    client
      .setEndpoint('http://localhost:90/v1')
      .setProject('PROJECT ID');
    const graphql = new Graphql(client);
    export default {
      name: "CurrencyApp",
      data() {
        return {
          currencies: [],
        };
      },
      methods: {
        async fetchCountryCurrencies() {
          try {
            const currencyQuery = (await graphql.query({
              query:
                ` query{
              localeListCurrencies {
              total
              currencies {
                code
                symbol
                name
             }
            }
        }`
            }));
            this.currencies = 
           currencyQuery.data.localeListCurrencies.currencies;
          } catch (err) {
            console.error(err);
          }
        },
      },
      mounted() {
        this.fetchCountryCurrencies();
      },
    };
    </script>

The web application's final appearance is shown in the picture below.

https://www.dropbox.com/s/gs8wxo73nh7l82h/currency-app.gif?dl=0

Conclusion

GraphQL APIs can transform front-end development by offering a more effective and simplified approach to getting data, significantly improving user experience, and opening up new doors for innovation in the web development industry. This post introduced us to GraphQL and provided an example of how to use Appwrite with GraphQL.

Resources

Why You Should Rethink Your Technology Stack

Ezekiel Lawson — Thu, 22 Dec 2022 08:32:41 +0000

Using a tech stack that is not functional or productive may result in missed opportunities, decreased productivity, and other drawbacks. And even though changing technology stacks can be challenging, businesses must assess their tech stack and make the necessary adjustments. This allows them to make sure that their technology supports their current and future business objectives and keeps them competitive in their sector.

In this article, you will discover:

The need to rethink your technology stack
The opportunity cost of an inefficient tech stack
Signs that your tech stack requires an audit
The benefits of migrating to a better tech stack
Are JAMstack and Appwrite right for you?

What is a Technology Stack?

Before diving into this topic, let's learn what a technology stack is. A technology or a tech stack is a list of technology tools, languages, and frameworks used in building software applications. You can employ a variety of technology stacks for building websites and applications. Some examples of common tech stacks include:

LAMP stack is composed of Linux (the operating system), Apache (the web server), MySQL (the database), and PHP (the programming language). It is commonly used for building dynamic, database-driven websites and applications.
MEAN is a web development stack comprised of four technologies: MongoDB, Express.js, AngularJS, and Node.js. The MEAN stack can be used to develop web applications that run on various platforms, such as desktop computers and mobile devices.
Ruby on Rails is a web application development framework written in the Ruby programming language. It is mainly used in building an application that follows the model-view-controller (MVC) design pattern. It uses technologies like Ruby, which is the (programming language), and Rails, the (web framework.)
.NET stack is a free, open-source, and cross-platform that allows you to construct a variety of applications, including online, mobile, desktop, gaming, and internet of things (IoT) apps.
JAMstack is the architecture for building modern websites, JavaScript (the programming language), APIs (for integrating with external services and data), and Markup (for defining the structure and content of the site or application). JAMstack is used for developing modern, high-performance, and secured websites and applications.

The Opportunity Cost of Inefficient Tech Stacks

The stack you use for your application determines the product you can develop and its effectiveness. Inefficient tech stacks can lead to slower performance, resulting in a poor user experience and a loss of potential customers. They can also require more resources to maintain and scale; increasing operating costs and reducing profitability. An inefficient tech stack can also limit a business's ability to take advantage of new technologies and opportunities, hindering its growth and competitiveness. Therefore, it is crucial for businesses to carefully evaluate their technology stack and ensure that it is effective and efficient.

Signs You Need A Tech Stack Audit

The tech stack audit plays a vital role in your business as it helps to find and resolve any technical overlap in your stack and allows you to cut costs by removing features you don’t need.

Here are some signs that your tech stack needs to be reviewed:

If your company has grown or changed in some way, your current tech stack may no longer be well-suited to your needs. For example, if you have started offering new products or services or expanded into new markets, your tech stack may need to be updated to support these changes.
If your tech stack is causing frequent issues or downtime, it may be a sign that it is not operating optimally. This can lead to lost productivity, frustrated customers, and other problems that can impact your bottom line.
When you have low confidence in the security and accuracy of your data.
When your stack can't support as many users as your application can handle and your business is sluggish due to inefficiencies.

Overall, conducting a tech stack audit is a good idea if you are experiencing any of the above issues or want to ensure that your tech stack is operating at its best. This can help identify areas where your current stack is not performing better and provide guidance on improving.

Benefits of Migrating Tech Stacks

The time for migration to a better stack is when your previous stack no longer meets your business requirements, is poorly maintained, lacks scalability, has low security, and has high development costs. All of these factors are crucial because the technology stack you use plays a significant role in your product's success. Before migrating your tech stack, here are the few things you need to ask yourself:

Does your business have the right tech stack?
Will your current stack support your future goals?

If not, you need to migrate to a better stack that will fit all your requirements. Following are a few of the key benefits.

High Performance and Scalability

One of the primary concerns to focus on is the user experience. Your application is a tool that demonstrates the quality of your business, and when your application performance is poor, it reduces the traffic and gives users a bad impression of your application. Migrating your stack to a better platform will increase your application performance and boost SEO, revenue, and conversion.

Better Support for New Technologies and Features

A new tech stack can provide better support for new technologies, such as artificial intelligence, machine learning, and the Internet of Things (IoT). This can help your company take advantage of these technologies and stay ahead of the curve in your industry.

Improved Security

When using a tech stack, security is the main priority. To prevent cyberattacks and data breaches, moving to a new stack will enhance your security architecture and drive you to choose platforms with the best security measures and data encryption.

Reduced Maintenance Cost

Migrating to a new stack can reduce maintenance costs as you transfer to the platform that has only the required resources and services you need. This will also help to cut out those features and third-party tools you don’t need.

Are JAMstack and Appwrite Right for You?

You can create your application using JAMstack and Appwrite, two web development tools that are each suited to a certain need. JAMstack is used to create static websites and online applications that need to be fast and scalable, whereas Appwrite is a backend platform that offers a selection of tools and APIs for creating and maintaining web and mobile applications. You should evaluate both options and use them based on your needs and project requirements.

How do you rethink your tech stack?

Finding a solution that fits your project's goals and timeframe while lowering development costs is crucial. One of the options that enable you to fulfill such demands is JAMstack.

It is known as the "modern web architecture" since it is secure, performant, up-to-date, and allows a lot of freedom to design an ideal finished result.

Some of the benefits JAMstack provides are:

A prebuilt markup file and assets through the CDN; making it the fastest way to deliver web content to users.
Greater flexibility while building cutting-edge, user-friendly applications and websites.
Making navigation on your website or application simple and engaging for consumers.
Building and deploying your website on the JAMstack architecture will reduce the development cost because hosting the static file is affordable and accessible.
It helps developers skip the stress of using a standard technology where it is difficult to build an end product and allows them to incorporate their favorite development tools while focusing on what matters.

Using modern web technologies, you can leverage JAMstack with a BaaS solution like Appwrite to build fast, secure, and scalable web applications.

Appwrite.io is a secure, open-source platform that allows developers to create fully functional web and mobile applications. It helps by cutting out the repetitive process of creating a modern application from the ground up and also reduces development costs since it is self-hosted and free to use.

Benefits of Using Appwrite as a BaaS Solution

It is self-hosted, meaning you can set up your server and network and handle all the maintenance in-house.
It has the best security practices to keep your application safe and protects users' files and data from cyber attackers.
It has a built-in file scanner and data encryption.
The documentation and online resources are beginner friendly, and you can quickly start.

Conclusion

Since the technological landscape is ever-evolving, businesses must stay up-to-date to remain competitive. You may miss out on chances to enhance your operations and acquire a competitive edge if your present technology stack is not utilizing the most recent trends and advancements.

Resources

Here are some helpful resources to get you started with Appwrite and JAMstack:

Appwrite Github repositories
Join the Discord community to ask questions and also learn more about the tool
Appwrite documentation for quick guides on how to integrate Appwrite into your application
Getting started with Appwrite for web
Getting started with JAMstack
Introduction to Tech Stack

The App-Building Platform for the Next Generation of Developers

Ezekiel Lawson — Fri, 30 Sep 2022 09:50:22 +0000

Application development app gives developers a centralized location containing all the tools required to build software apps. Many of these platforms provide services like code integration and mobile development, while others offer other elements of development tools, including code debugging, code review, collaboration, and more.

Appwrite is one of the future platform developers use to develop their applications since it gives them all the fundamental functionalities and APIs needed to create any fast and efficient web or mobile application. This article will examine Appwrite's features and why it is one of the best platforms for building applications.

What is an Application Development Platform?

An application development platform is software that gives developers all the tools they need to manage, test, deploy, and build a strong and secure application. These platforms are designed primarily to help the agile technique and accelerate the production of mobile and online applications. There are various programs for testing, managing, and building our applications, but let's focus on Appwrite.

What is Appwrite?

Appwrite is a new and secure open source platform that helps developers create core API (Application Programming Interface) for the web and mobile. It allows programmers to create quick applications. It is self-hosted, free to use, and easy to set up. However, you can pay for the cloud version if necessary.

Features of Appwrite

Appwrite is a development platform that seeks to abstract the complexity of developing from the ground up and the repetitive processes required for creating a modern app. Appwrite provides a variety of services, including:

Database Management
Appwrite allows developers to query, save, and manage access to their app data or document in real-time using a robust and flexible database. You can also create numerous databases.

Storage
The Appwrite storage service allows users to upload, download, and manage their files securely and efficiently. Appwrite’s server offers the built-in capability to reduce and encrypt files, but only for smaller files. The latest version of Appwrite also permits massive file uploads, as opposed to prior versions, limiting your file to the amount of free space you have available.

Data Control
Appwrite provides you full access and control over your data as a developer, allowing you to set up a self-hosted solution for your application simply.

Full Security
Security is crucial in the development process since you must monitor your application. Appwrite improves application security by providing end-to-end protection for your backend APIs from storage to the cloud or while the data is stored.

Appwrite additionally safeguards your data from brute force assaults. This implies that all of your passwords and API keys will be encrypted using the Bcrypt method, making it difficult for attackers to decrypt saved passwords or get hold of your API keys.

Simple Authentication
With the Appwrite Authentication service, you can authenticate, confirm, and manage your users using several sign-in techniques. You can also use the system to change user information and retrieve user security data with current activity.

Geo and Localization
With the Appwrite location API, you can customize your application based on your user's location. You can also track the user's IP address, Phone Codes, and list of countries.

Why is Appwrite the Building Platform for the Next Generation of Developers?

Appwrite is believed to be one of the most excellent Backend-as-a-Service platforms for web and mobile developers since it decreases the complexity and repetitiveness required to design an application. Developers can also create safe and speedier applications with the support of including user authentication and third-party technologies in their applications. Appwrite is fully secured and flexible to get started.

It also provides tools to build rapid applications with various built-in features to assist you in getting started without writing from scratch. You can integrate some of your favorite technologies with Appwrite, such as JavaScript, Python, Node.js, React, PHP, Kotlin, Swift, Flutter, and Deno. Other tools provide comparable solutions to Appwrite; however, here are some reasons why Appwrite is ideal:

It is free and easy to set up.
It is fast and secure with a built-in file scanner and encryption.
It has a simple learning curve and other good resources to get you started.
Appwrite includes end-to-end encryption for your backend API.
You have complete access control to your data and files. The community is large and supportive.

Here are some helpful resources to get you started with Appwrite:

Appwrite Github repositories
Join the D iscord community to ask questions and also learn more about the tool
Appwrite documentation for quick guides on how to integrate Appwrite into your application
Getting started with Appwrite for web

Conclusion

Finding the perfect Backend-as-a-Service platform that is versatile, secure, pleasant, supportive, and easy to set up when creating can be a burden, especially if you are coming from a place where you have to write all the backend code for the server, construct, and manage databases. Appwrite is the most excellent solution because it simplifies the development process. In this article, we discussed one of the (BaaS) tools and why it is great for new developers.

EIGHT SECURITY TIPS TO PREVENT YOUR WEB APPLICATION FROM BEING HACKED

Ezekiel Lawson — Fri, 24 Sep 2021 10:33:33 +0000

EIGHT SECURITY TIPS TO PREVENT YOUR WEB APPLICATION FROM BEING HACKED

Web application security is one major point in web app development that is not properly focused on when building an application. But it is a major priority if you plan on taking your application online. Luckily, in this article, I'm going to walk you through what web application security is, why it is important, and how to secure or prevent your web application from being hacked.

Here are some of the security vulnerabilities we will cover in this tutorial

Unrestricted File Upload
XSS Attack
Software Update
Authentication
End-to-End Encryption
DDoS attacks
Captcha -Npm Dependency Vulnerabilities

What is web application security?
Web application security deals specifically with the security surrounding websites, web applications, and web services such as APIs from attacks by internet-based threats. In other words, the security measures at the application level that aim to prevent data or code within an application from being stolen or captured.

Why is it important?
It is important in today's applications because it is a central component of any web-based business. It prevents malicious agents and cyber thieves from accessing sensitive information from your applications.

Now, let's look at some of the threats and how to prevent them.
Unrestricted File Upload
It is one of the security vulnerabilities that can cause or bring threats to your application. Some web applications allow users to upload files such as pictures, documents, videos, Which can cause threats by giving the malicious agent access to upload bad files.

How to prevent it:

You must check for vulnerabilities in a file that is uploaded to your application
Only permit specific file type
Rename files when they are uploaded
Always scan your file for malware
Confirm file formats and extensions

Cross-site scripting attack (XSS)
Cross-site scripting (Which is known as XSS ) is a type of security vulnerability commonly found in web applications. These attacks enable attackers to insert client-side scripts into web pages viewed by other users. It occurs when a malicious script is injected directly into a vulnerable web application, XSS allows attackers to execute scripts in the victim’s browser which can hijack user sessions, destroy websites, or redirect the users to malicious websites.

There are three types of XSS attacks

Reflected XSS
Stored XSS
Dom Based XSS

I will give a little definition of each of these attacks.

Reflected XSS: Reflected XSS attacks, also known as non-persistent attacks, is a form XSS where the cross-site component occurs temporarily as a result of user input being reflected into the DOM

Stored XSS: In stored XSS, is a form of cross-site scripting script execution in which the payload (typically Javascript) is persisted typically in a database it is distributed by the application itself by nature of being rendered via application logic from the server's database

Dom Based XSS: is an XSS attack that arises when an application contains some client-side JavaScript that processes data from an untrusted source in an unsafe way, It is usually caused by writing data to a potential sink within the Dom.
One thing that can lead to this attack in your application is your HTML element

One of the libraries we can use for sanitization is DomPurify.

DOM Purify
DomPurfiy is a library that we can use for the sanitization of HTML, MathML, and SVG. It's an XSS sanitizer.

You can check out the package on Npm's official website.

https://www.npmjs.com/package/dompurify

How to prevent it:

Never insert untrusted data in your application
Try to use interpolated expressions that are stringified and cannot be outputted on the browser
Always ensure that the data coming from your code is sanitized and purified with Dom Purifier
Ensure the data passed through prop is rendered the proper way be it v-html or document.write
Always use what the framework suggests except v-html
Do not render templates server-side keep them static

Software / Library Update
There is always a high risk involved when we use a package or libraries that are not up to the latest version it can cause harm to our application and give these hackers access to our application.

How to prevent it

Constantly update your packages or libraries manually to the latest and secured version
Check the security flaws of this library or package to be sure they are not at risk.
Always add the older version of your packages to the newer ones.
Always use the selective third packages or libraries which are well-managed, well-documented, and recommended.
Continuously update your Npm packages to avoid dependency errors.
Always check them for known vulnerabilities use Npm audit to fix them

Code example

npm audit fix

End-to-End Encryption

End-to-end encryption (E2EE) is a method of secure communication that prevents third parties from accessing data while it's transferred from one device to another. It is another way of securing your application from malicious users. E2EE is very necessary for application because it reduces the number of parties who might be able to interfere with the encryption

Captcha
It's another means of securing your application, It is used to authenticate that a real person or user is accessing your application in other to restrict spammers or bots that tries to access email address, Captcha is used for addressing larger audiences for a large scale project.

Advantage

It helps in preventing automated spam submissions
It blocks robot software from submitting a fake request
It protects the integrity of online by resisting hackers using robots to send in repeated false responses.

Npm Dependency Vulnerabilities
It is very good to audit your dependency packages to check if they are upgraded to the latest version or not

Use the command npm audit to audit your packages and check for the outdated versions of packages, vulnerable packages and upgrade hem to the latest version

Distributed denial-of-service attack (DDoS)
A DDoS attack is an attempt by the attacker to create so much traffic to an internet application that prevents the traffic flow of normal visitors.

Below is a sign of a DDoS attack

Webpage Not Found: This is one of the signs of a DDoS attack, where a particular website can not open or is not found.

Increase of EMail Spam: This is another sign where there is a very high increase in email spam.

Slow Network Performance: This is a situation where the network is being slowed down when attempting to open files stored on the network or when accessing files in the application.

How to prevent it :

Develop a response plan/team members
Secure the network
Practice a good network security

Authentication
Authentication is an action of verifying the identity of a user or process. When authentication is broken it can allow attackers to access the user's data or information and cause harm to your application. one of the ways attackers can access user's data through authentication is

Improper login
An improper login can lead to data exposure which can cause havoc by attackers to your web application.

Displaying error messages for authentication
While you are authenticating a form on your web application you must be very careful not to display just a single error message when a user enters a wrong password "Your password is incorrect" This can give the attacker the mindset that the email address or user id is valid while the password is wrong, This can allow the attacker to start suggesting the password for that user. The best way is to display this error is "Incorrect username or password"

Here is a simple diagram example

Session IDs exposed in a URL

A session ID is a special number that a Web site's server assigns a specific user for the duration of that user's visit (session)

If you place a session token directly in the URL, it increases the risk of an attacker capture and exploits it. When you connect to the webserver using HTTPS the risk is less than if you use HTTP but it is still a threat. HTTPS URLs are encrypted during transmission but are often stored in server logs.

Improper Form Validation
If the data entered into a form input is not properly validated, or in the right format, it will lead to injection attacks, memory leakage, and compromised systems.
Validating your form is important in your application because a form can be submitted without the user completing all the required fields. But this level ensures that all fields are confirmed when the user tries to submit the form.

This is an example of a formatted input defining the input type as "email" it ensures the input is that of an email address

<input type="email" name="email" placeholder="your_email@mail.com" required/>

Form sanitization
Form sanitization is the process of keeping your form input clean, filtered, and sanitized from a malicious agent.

How to prevent all of these attacks:

Implement proper logging by making sure a user is well authenticated with a two-factor authentication
Never display a single error message this can give the user access to suggest each data that's missing and hack the user's data in your application
Always use a strong password when suggesting passwords to your users in your application
ensure you are using a "secure enough" random generator to build the token.
Never store session id in a URL
Always make sure user form input is properly validated and sanitized.
Provide minimum authentication for your users

Doppler is one company trusted with serving hundreds of millions of secrets to developers and their apps in a secure, performant, and reliable way. A love for security is built into the core of our DNA.

You can check their official website to learn more about security

https://www.doppler.com/security

Conclusion
Securing your application is necessary because it keeps hackers and cyber thieves from accessing sensitive information in your application. It also builds customer confidence by keeping their data secure.

Wow, That was a great article. In this article, we have learned what web application security is, why it is important, and how to secure your application form cyber thieves.

Thanks for reading please feel free to add your idea on what I have covered let's improve the security of our application against malicious agents cheers!!!!

REFERENCE

https://owasp.org/www-project-top-ten/

WAYS TO BECOME A GOOD FRONT END DEVELOPER

Ezekiel Lawson — Mon, 20 Jul 2020 12:59:49 +0000

Learn HTML & CSS. And become good at it. I guess there’s no way around it. Learn HTML & CSS. Why? Because of the basics matter.

There are all kinds of different online courses available on how to get started with HTML and CSS. First things first. Sign up at Online courses like Coursera or Team Treehouse. After finishing some initial courses, go ahead and create some static web pages and iterate over and over again.

I also recommend developing some small UI elements for practicing your newly learned HTML & CSS skills. Codepen.io is a great playground for that. Browse other people’s projects and participate in the community there.

Build things. Playing around with (small) UI elements is one thing. Creating an actual landing page or website is something different. At some point, you will eventually start using JavaScript snippets.

Don’t forget to challenge yourself by building the first responsive elements.

So there’s only one way to become better at what you’re doing: Keep learning, keep building.

Putting these two together, build to learn! There’s no better way to learn than to get your hands dirty. You’ve probably heard this a hundred times by now, but it is for a good reason why this is the advice most often dished out.

Read, read, read I guess there’s no way around this. Believe it or not. Your reading skills greatly influence your path to becoming a great front-end developer. Especially when starting out, there’s a lot of reading required. Why?

At first, you’ll probably read a lot of articles, guides, and manuals on how to do different things. You’ll also start reading other people’s code.

Or as Adam (UX Lead at CoachUp) would state:

Combine that with a good book like Eloquent JavaScript, and you can up your programming game very quickly.

There’s more to front-end development than building a website If you followed my tips from 1 to 3, you have probably already done a course or have read a lot of tutorials and are now able to throw together a website.

However, that doesn’t equate to being a “front-end developer”. Knowing how to build a website is a very small part of the front-end puzzle.

I apologize if that sounds demotivating. But that’s actually the case.

There is a whole load of topics that you still should learn about. If we consider performance, testing, QA, and many other areas, then you really need to become a deep diver as a front-end developer.

Know your tools As you start your journey with front-end development, you will need to decide on your toolkit and the services you need to make your life easier. Learning about the different tooling options is an important thing. Great tools will help you enhance and automate your front-end development workflow.

There will be an ocean of possibilities but soon enough, you’ll find yourself using certain tools and apps. One of those tools will definitely be the Chrome developer tools. Why? Because you can play with HTML, CSS, and JavaScript in real-time and this will give you the immediate feedback you need to learn quickly.
Additionally, node, npm, bower, and many more excellent tools are there to facilitate your daily work. And don’t forget about versioning.

Version control will save your life. OK, maybe this sounds a bit too exaggerated. But trust me on that. Version control will save you some sleepless nights.

Instead of trying something and having it blow up in your face or hitting command+z a trillion times, you can simply trash your branch and roll back to what was working previously.

So make sure to become an expert at Git.

Do not rush. Along the way, you will ask yourself why you do this and you may want to just stop. It may be tempting to just give up. But don’t. If you’re at that point, I have only one advice for you:

Do. not. give. up.

Set aside one or two hours every other day to learn. Take a lot of breaks and make sure that you really know the basics. And never rush.

The basics form the foundation which will help you get to the next level.

If you feel stuck, don’t be afraid to ask questions. Everyone goes through this phase and having the patience to stick it out will help you come out in the end as a pro in front-end development.

Thanks for spending your time to read this hope it helps you out
please feel free to add more

How to become a good programmer(Junior Programmer)

Ezekiel Lawson — Wed, 13 Nov 2019 09:34:49 +0000

Dear junior dev

don't be scared of making mistakes
don't be scared of trying something new
don't be afraid of airing your opinion
don't be scared of losing
believe in yourself
take that risk
no excuses
take responsibility
be brave
show working
live the dream 🔥🔥🔥🔥