Forem: Ukagha Nzubechukwu

Why Most Business AI Fails — And How RAGS Gives Companies a Real Brain.

Ukagha Nzubechukwu — Tue, 13 Jan 2026 07:52:28 +0000

Most businesses fail at AI, not because the technology is flawed, but because their AI doesn’t know the business. It talks, it responds, it even sounds confident, but underneath the surface, there’s no understanding, no memory, no connection to how the business works. That’s where the gap opens up. When AI lacks context of your policies, data, processes, or decisions, it produces noise instead of value. And in today’s market, that gap (the presence or absence of real intelligence) is what separates companies that successfully use AI for growth from those that waste money on it.

The same question, one generated by a general-purpose AI, and the other by an AI informed by the organization’s internal policies and rules.

The most effective AI doesn’t rely on generic answers or prewritten flows; it actively pulls from internal documents, reports, policies, and historical records to respond with precision. This approach is known as RAGS (Retrieval-Augmented Generation Systems), which enables AI to retrieve relevant information in real-time and utilize it to form accurate, context-aware responses. Instead of guessing, the system answers based on what your company actually knows, making it more dependable, more scalable, and far better aligned with real business needs.

This post looks at why AI without real knowledge fails in business, and why systems built with RAGS consistently outperform those that aren’t. More importantly, it shows why RAGS isn’t an add-on or a nice-to-have, but the foundation that determines whether AI becomes a real asset or an ongoing expense. To understand why this difference matters so much, we need to examine how most business AI is currently built, and where it falls short.

TL;DR: Here is the GitHub repository where you can find the policy documents and the n8n RAGS workflow used in this article.

Why Most Business AI Breaks Before It Delivers Value

Most business AI relies on lengthy prompts, predefined workflows, and carefully written rules meant to cover every scenario. It looks efficient at first, but it only works when employees or customers ask the “right” questions in the “right” way — something real businesses rarely do. Without RAGS, AI has no access to real company knowledge, so it begins to guess.

The AI may respond quickly and confidently, but its answers are assumptions, not facts. Without RAGS grounding responses in actual documents, data, and decisions, AI becomes a source of uncertainty, causing employees to lose trust and customers to get frustrated; humans are pulled back in to fix mistakes the system was supposed to prevent.

As the business grows, the problem compounds. Every new policy, product, or process introduces rules the AI doesn’t know, requiring manual prompt updates and constant maintenance. Teams spend more time managing the AI than benefiting from it, and leadership begins to question the return on investment. This isn’t a technology failure — it’s the absence of RAGS. AI that isn’t connected to real business knowledge doesn’t fail loudly; it fails slowly, draining trust, time, and resources.

At this point, better prompts won’t help. The system doesn’t need more instructions — it needs RAGS, a way to understand and retrieve the business knowledge it’s meant to support.

What Is RAGS and Why It Matters

RAGS stands for Retrieval-Augmented Generation Systems. RAGs change how AI language models generate answers. AI models produce text based only on patterns they learned during training. With RAGS, the AI first looks up information from trusted sources, like company documents, databases, reports, or knowledge bases, before generating an answer.

RAGs make AI’s responses more accurate and up-to-date. For example, large language models like GPT-4, or LLaMA are very good at predicting text, but don't know an employee’s current leave balance or the latest project deadlines. Without RAGS, these models might give confident but incorrect answers, mix reliable and unreliable information, or misinterpret specialized terms.

RAGS works in four steps:

Retrieve relevant knowledge: When a user asks a question, the system searches across approved knowledge sources ( documents, databases, policies, reports, or APIs ) to find the most relevant information. This search is done using embeddings, which allow the system to match meaning, not just keywords.
Add context to the prompt: The retrieved information is injected into the prompt as context. This step is what “augments” the model. Instead of guessing, the AI now has direct access to the exact material it should be using to answer the question.
Generate a grounded response: The large language model uses both its training and the retrieved context to produce a response that is accurate, specific, and aligned with current business knowledge.
Stay current without retraining: When documents or data change, the knowledge sources are updated — not the model. This keeps responses current without the cost or risk of retraining the AI.

In business, RAGS turns AI from a “confident guesser” into a reliable decision-support tool. For example, an employee could ask, “How many vacation days do I have left this year?” and the system would retrieve the actual balance from the HR database before answering, while a manager could ask, “Which suppliers meet our latest compliance standards?” and the AI would pull the relevant documents to provide a precise response.

With RAGS, companies get answers that are accurate, relevant, and traceable. Leaders can trust that the AI reflects how the organization actually works and not just patterns in text it has seen before.

Why RAGS Is a Foundation, Not a Feature

When AI is built on RAGS, the change is immediate and practical. In large insurance organizations, this shift has enabled customer service teams to answer inquiries more accurately by pulling directly from official policy documents and internal guidelines. The result is less time spent repeating explanations, fewer errors in describing processes or exceptions, and smoother handoffs across teams. Across the organization, friction drops not because people are working harder, but because the system finally understands what it’s talking about.

This shift creates confidence at every level. Teams trust the answers they receive because they are consistent and traceable to real sources. Customers feel heard instead of redirected, which reduces escalations by approximately 30% and enhances resolution times by nearly 20%. Leaders achieve more predictable outcomes and lower operating costs, as AI improves by keeping knowledge up to date, not by retraining models or rebuilding systems from scratch. These improvements not only enhance customer experience but also contribute directly to the bottom line, showcasing a clear return on investment for adopting RAGS.

Most importantly, RAGS changes the economics and longevity of AI. Building on these benefits, instead of constantly retraining models to keep up with business needs, companies update their knowledge sources and let the AI retrieve what it needs in real time — even across different product lines or regulatory environments. This keeps information current, reduces implementation costs, and gives organizations more control over what the system can access and say.

Companies that build AI on RAGS can adapt policies, launch new products, and scale operations without re-engineering their systems each time, while keeping access to sensitive information tightly controlled to meet regulatory and compliance requirements. Those that don’t are forced into retraining models, fixing errors, and managing workarounds as complexity grows.

Conclusion

AI doesn’t fail because it lacks intelligence, it fails because it lacks context. When systems aren’t connected to the knowledge that actually drives decisions, they drift, make mistakes, and slowly erode trust. Every confident answer becomes a potential risk, every recommendation a guess rather than a fact-based decision. RAGS closes that gap by grounding AI in the information that matters. For example, a retail company like Acme Retail can have AI instantly check inventory levels, pricing rules, and promotion policies before responding to a customer query — turning a system that guesses into a system that reliably informs decisions.

For companies planning their AI strategy, the choice is no longer about picking the right model or software. It’s about whether the intelligence you deploy is grounded in knowledge or built on guesswork and whether it earns trust or requires constant supervision. AI powered by RAGS changes the game: it delivers accurate, context-aware responses, even outside business hours, so customers can complete transactions confidently, employees can make informed decisions, and every interaction buids trust. Grounded in knowledge, AI doesn’t just answer questions, it keeps users engaged, supports teams, and becomes a reliable asset that grows businesses.

How to send Automated Personalized Cold Emails with n8n to Boost Response Rates

Ukagha Nzubechukwu — Wed, 08 Oct 2025 22:19:12 +0000

Generic cold emails get deleted faster than spam these days. Yet, personalizing each email for hundreds of prospects is a productivity nightmare no individual or sales team can afford.

Many email marketing campaigns fail to achieve their desired impact primarily because they lack personalization and specificity. When email providers like Gmail perceive your email as "generic", they are more likely to be categorized as promotional content or, worse yet, as spam. This misclassification prevents their delivery to the intended individuals.

Even if your emails bypass spam filters and land in the inbox, they risk being ignored or dismissed. Potential clients will skim over them, viewing your message as just another faceless message that takes up important space in their email storage.

Personalizing your message signals authenticity and shows you’ve taken the time to understand the person and their interests. Mention a specific trigger, for example, “I noticed your team is hiring a new sales manager.” This shows awareness of their situation and opens a timely, relevant conversation. That kind of specificity makes recipients far more likely to stop, read, and respond.

In this guide, I will show you how to build an n8n workflow that generates personalized email content and automates the sending process, all while ensuring compliance and deliverability.

Important — scope of this guide
This is an introductory walkthrough for setting up an n8n workflow that personalizes and sends emails. I don't cover list scraping or acquisition techniques; the guide assumes you already have a lawful, consented email list.

Prerequisites

To complete this guide, make sure you have the following items ready;

An n8n account.
A prepared email list (Google Sheet recommended). I've provided a template for you. Open this spreadsheet and make a copy for your use. This Google Sheet already includes the necessary headers, such as First Name, Email, Title, Company, LinkedIn, Website, Summary, Industry, and Location. Additionally, you can add extra columns for further personalization.

Note: Don’t worry if fields like Subject, icebreaker, elevatorPitch, callToAction, or postscript are empty, the workflow will fill those automatically.

No n8n experience required, this guide walks you step-by-step through the entire process.

Why Traditional Cold Email Doesn’t Work Anymore

The old strategy of mass “spray and pray” emails has lost its effectiveness. These impersonal communications are quickly flagged as spam or deleted, often before they even get a chance to be read.

While high-touch outreach from Sales Development Representatives (SDRs) can yield better replies, this method is not scalable. A single SDR may only be able to send a limited number of meticulously crafted emails each day, resulting in a slow and costly process that can burn teams out. Manual research produces quality, but not the volume most teams need.

A more effective strategy is to adopt a hybrid approach that combines the benefits of automation with genuine contextual personalization. n8n allows you to personalize messages with warm triggers and craft introductory lines that feel human. This method ensures that your outreach feels thoughtfully composed and tailored to each individual, all while helping you to reach a much larger audience. By doing this, you increase your inbox hit rate and also significantly improve response rates, transforming your outreach from mere noise into meaningful conversations.

How to Send Automated Personalized Cold Emails with n8n

You will sign up for n8n to create a workflow that automatically pulls your email list, generates personalized outreach messages with ChatGPT, and sends your first targeted campaign.

Step 1 — Create an n8n account

To begin, visit n8n’s website and create a free account, no credit card required. You get a 14-day free trial, so there’s no need to worry about being charged while you try the platform.

Step 2 — Add your trigger

After login, you’ll land on your n8n dashboard.

Click “Start from scratch” to open the workflow editor, and then, hit the “Add first step” button to add your trigger node, the starting point of everything your workflow will do.

Quick note: A trigger node is what starts your automation. Think of it as the “on switch.” It can be almost anything: a button you click, someone submitting a form, a new row appearing in your spreadsheet, or even a schedule (like “every morning at 9 am”).

For this guide, choose Trigger manually.

This starts the workflow only when you click the play button. It’s the easiest way to test things while you’re just getting started.

Step 3 — Connect your Google Sheet to the workflow

Now that your workflow has a trigger, it’s time to bring in your spreadsheet. This is where your email list lives, so you want n8n to grab that data and pass it along to the rest of your automation.

Click the "+" button after your trigger node, search for Google Sheets, and select it. From the list of actions, choose "Get Row(s) in Sheet".

It’s okay if your “Credential to connect with” looks different. That just means I’ve already set one up; I’ll guide you through the process anyway.

In the Credentials field, open the dropdown and select "Create new credential". Then, click "Sign in with Google", and sign in with your account. Once connected, you will see a message that says "Account connected."

In the Resource field, select “Sheet within Document.”

For Operation, choose “Get Row(s).”

Under Document, keep “From list” and select the spreadsheet that contains your email list.

In Sheet, keep “From list” and choose the sheet with your contacts.

You can ignore the filter options for now; they’re only useful if you want to pull specific rows.

Finally, test your spreadsheet node by clicking Execute step. If everything is working, you’ll see your spreadsheet data appear in the output tab, ready to be used in the next step of your workflow.

Make sure to click the pin icon in the top-right corner of the output panel so the data is visible while you configure the next node. This way, you don’t have to rerun this node every time.

Step 4 — Personalize your emails with ChatGPT

In this step, you’ll pass each row from your Google Sheet into an OpenAI model, which will generate a personalized email for you.

Click the “+” button after the Google Sheets node, search for OpenAI, and choose "Message a model".

You’ll see the Google Sheets data in the left panel. This is what the model will use for personalization.

In the "Credential to connect with" input, open the dropdown and click "Create new credential". A pop-up will appear where you can enter your OpenAI API key.

To retrieve your API key, visit the OpenAI platform. Then, return to the n8n popup, paste the secret into the API key field, and save. If everything is done correctly, you will see a message saying the connection was tested successfully.

Keep the Resource input set to its default option, which is "Text".

For the Operation input, leave it at its default setting as "Message a model".

Select a model from the dropdown menu: if you're using n8n's free credits or a free OpenAI account, choose a smaller model; if you have a paid OpenAI account, opt for a more powerful one.

For the message field, you have two sub-fields: "prompt" and "role". In the prompt sub-field, enter the following text:

You are a helpful assistant whose role is to personalize emails and make them more human.

In the role sub-field, select "System."

To proceed, click on "Add message" to add another sub-field. In the prompt input, enter the following block of text below and set the role to User:

Full prompt — Click to expand!

You are a concise outbound email writer. For each spreadsheet row, you are given the following input fields:
Civility, First Name, Last Name, Full Name, Title Description, Email, Profile (URL), Title, Company, Company Legal, Company Phone, Company Website, Company LinkedIn, Company Summary, Industry, Company Location.

Goal: produce a short, human-feeling outreach email broken into 5 parts:
{"subjectLine":"", "iceBreaker":"", "elevatorPitch":"", "callToAction":"", "ps":""}

Task steps (must follow in order):
1. Quick research (web): using the Profile URL, Company Website, Company LinkedIn and public sources (news, Crunchbase/AngelList, product pages, recent posts), gather 3 one-line facts:
   a. What the person actually does / focus (paraphrase — do NOT copy LinkedIn text verbatim).
   b. One recent signal or behavior you can mention (product launch, press, hiring, content they posted, conference talk).
   c. A concise, credible gap or opportunity for the company (one sentence) — e.g., lead-gen funnel unclear, demo scheduling low/no automation, pricing page confusing, low content-to-conversion flow, no obvious appointment pipeline. When unsure, default to a safe, general, plausible gap framed as an *opportunity* rather than a failure.

2. Third-party/company comparison: identify one relevant peer/competitor/adjacent company and note a single, tactful difference or shortcoming you can use as a contrast to frame an opportunity for your prospect. Keep it high-level and non-judgmental.

3. Build `thingAboutThem` and `relatedThing`:
   - `thingAboutThem`: a short phrase (3–6 words) summarizing the person’s focus or recent initiative (e.g., "lead gen for SMBs", "product-led growth", "enterprise onboarding").
   - `relatedThing`: a related phrase you can reference in the icebreaker (e.g., "your recent blog on demo conversions", "the webinar you did on onboarding").

4. Compose outputs with these constraints:
   - Tone: "casual bar conversation", spartan, plain language, short sentences.
   - No fancy jargon. Use one human-sounding sentence for each field where possible.
   - Subject line: lowercase, ≤60 characters, include First Name and `thingAboutThem` if natural (format: `hey {FirstName}, quick thought re: {thingAboutThem}`).
   - Icebreaker: 10–25 words. Specific detail from research, paraphrased (do not paste profile copy).
   - Elevator pitch: one short sentence (≤18 words) with a plausible, quantifiable result (use ranges like "~$X/mo" or "% lift" and hedge with "can", "likely", "typically").
   - Call to action: 1–2 sentences. Offer a low-friction next step (15–30 min call / free audit) and a risk-minimizing guarantee (e.g., "I'll guarantee X or you don't pay", or "I'll prove value in 2 weeks").
   - PS: 5–12 words, curious & conversational.

5. Safety & accuracy rules:
   - Do NOT invent awards, numbers, or proprietary customer names. If no public evidence exists, say something plausible but hedged ("looks like", "appears", "seems").
   - Never state private data you can’t verify. If profile or company pages are unavailable, use neutral, general icebreakers referencing industry trends.
   - Keep claims defensible and small. Avoid legal, medical, political claims.

6. Output: only return one JSON object exactly in this format (no extra text):
{"subjectLine":"", "iceBreaker":"", "elevatorPitch":"", "callToAction":"", "ps":""}

7. If a required field from the spreadsheet is missing, fall back:
   - Missing Profile URL: use Company Website / Company LinkedIn first. If none, use industry-level icebreaker.
   - Missing CompanySummary: summarize the Company Website homepage (1 short phrase).

Add yet another sub-field. In the prompt input, enter the following block of text below and set the role to User.

This block represents the JSON data from your spreadsheet, and it’s important because it passes the right fields (like name, company, and profile) into the prompt so each email can be personalized correctly

Full prompt — Click to expand!

Civility: {{ $json.Civility }}
First Name:  {{ $json['First Name'] }} 
Last Name: {{ $json['Last Name'] }} 
Full Name: {{ $json['Full Name'] }}
Title Description: {{ $json.Title }} 
Email: {{ $json.Email }} 
Profile (URL): {{ $json.Profile }} 
Title: {{ $json.Title }}
Company:{{ $json.Company }} 
Company Legal: {{ $json['Company Legal Name'] }} 
Company Phone: {{ $json['Company Phone'] }} 
Company Website: {{ $json.Website }}
Company LinkedIn:{{ $json.Linkedin }} 
Company Summary: {{ $json.Summary }} 
Industry: {{ $json.Industry }} 
Company Location: {{ $json['Company Location'] }}

Finally, toggle "Output Content as JSON" to ON.

We are ready to execute this step; click the "Execute step" button. Your AI will return a JSON object containing fields like subject line, icebreaker, and call-to-action.

Step 5 - Update Google Spreadsheet

Now that your OpenAI node is generating personalized emails, the next step is to send those results back to your spreadsheet.

To begin, click the “+” button after your OpenAI node, search for Google Sheets, and select “Update row in sheet”. You’ve already worked with this node earlier, so most of the setup will feel familiar. Let’s walk through the key parts quickly:

In the “Credential to connect with” field, keep the default option. n8n will automatically reuse the same Google Sheets credential you created earlier.

Leave Resource set to “Sheet within document” and Operation as “Update Row”.

In the Document field, choose “FROM ID”. Next, go to your Google Sheet and copy the ID from its URL. A typical spreadsheet URL looks like this:

https://docs.google.com/spreadsheets/d/<1YjJeRUDXAKGEc-xYv_GfSj3E8s7YDPQwhgDrx9fYsCQ>/edit#gid=784785913

The spreadsheet URL does not include angle brackets (< >). I added them to indicate where to copy.

Copy the Google Sheet ID from the URL and paste it into the input field next to “FROM ID”.

For the Sheet field, leave “From list” selected, then choose the specific sheet that holds your email data.

Keep Mapping Column Mode as it is. In the Column to match on, select "Email". This ensures that each row is matched to the correct contact, preventing updates to the wrong row.

Now, fill in the values to match the fields with the data from your previous steps.
You can paste the expressions below or drag and drop the fields from the left panel.

Full prompt — Click to expand!

Email (using to match): {{ $('Get row(s) in sheet').item.json.Email }}
Civility: {{ $('Get row(s) in sheet').item.json.Civility }}
First Name: {{ $('Get row(s) in sheet').item.json['First Name'] }}
Last Name: {{ $('Get row(s) in sheet').item.json['Last Name'] }}
Full Name: {{ $('Get row(s) in sheet').item.json['Full Name'] }}
Title: {{ $('Get row(s) in sheet').item.json.Title }}
Profile: {{ $('Get row(s) in sheet').item.json.Profile }}
Company Name: {{ $('Get row(s) in sheet').item.json['Company Name'] }}
Company Legal Name: {{ $('Get row(s) in sheet').item.json['Company Legal Name'] }}
Company Phone: {{ $('Get row(s) in sheet').item.json['Company Phone'] }}
Company Website: {{ $('Get row(s) in sheet').item.json['Company Website'] }}
Company LinkedIn: {{ $('Get row(s) in sheet').item.json['Company LinkedIn'] }}
Company Summary: {{ $('Get row(s) in sheet').item.json['Company Summary'] }}
Industry: {{ $('Get row(s) in sheet').item.json.Industry }}
Company Location: {{ $('Get row(s) in sheet').item.json['Company Location'] }}
Title Description: {{ $('Get row(s) in sheet').item.json['Title Description'] }}
Subject: {{ $json.message.content.subjectLine }}
Icebreaker: {{ $json.message.content.iceBreaker }}
Elevator Pitch: {{ $json.message.content.elevatorPitch }}
Call To Action: {{ $json.message.content.callToAction }}
Postscript: {{ $json.message.content.ps }}

Make sure every field has a value; otherwise, n8n might skip empty ones.

You can also drag-and-drop values directly into each input if you prefer. Here is a video to show you how it's done.

And finally, click "Execute Step" to append your personalized email content to your spreadsheet.

Step 6 — Send your personalized emails automatically

Now that your spreadsheet has all the personalized fields (subject line, icebreaker, pitch, call-to-action, and postscript), you can automatically send your emails using the "Send a message" Gmail node.

In this step, you can either use your Gmail account to send emails or choose the SMTP option if you prefer to connect your own mail server or a service like SendGrid. For this example, use the Gmail option; the SMTP method is straightforward and similar.

To begin, click the “+” button after your last Google Sheets node, search for Gmail, and select "Send a message".

In Credential to connect with, click "Create new credential" and sign in with the Gmail account you’ll use to send.

Leave the Resource field set to Message and Operation as Send.

Set the To field to

{{ $json.Email }}

Set the subject field to

{{ $json['Subject'] }}

Set Email type to HTML and paste the HTML template into the Message field:

Full html — Click to expand!

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Email</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="x-preheader" content="{{ ($json['iceBreaker'] || 'Quick thought for you') }}">
    <style>
      :root{
        color-scheme: light dark;
        supported-color-schemes: light dark;
      }
      @media (prefers-color-scheme: dark) {
        .card { background: #111111 !important; }
        .body { background: #0b0b0b !important; }
        .text { color: #f2f2f2 !important; }
        .muted { color: #bbbbbb !important; }
        .btn { background: #4f46e5 !important; color: #ffffff !important; }
        .divider { border-color: #2a2a2a !important; }
        .chip { background: #1c1c1c !important; color: #e5e7eb !important; }
      }
    </style>
  </head>
  <body class="body" style="margin:0;padding:0;background:#f6f7fb;">
    <table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background:#f6f7fb;">
      <tr>
        <td align="center" style="padding:24px;">
          <table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="max-width:640px;background:#ffffff;border-radius:14px;overflow:hidden;box-shadow:0 6px 24px rgba(0,0,0,0.06);" class="card">
            <tr>
              <td style="padding:18px 22px;background:linear-gradient(135deg,#6366f1,#22d3ee);">
                <div style="font:600 14px/1.2 -apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Arial,sans-serif;color:#ffffff;letter-spacing:.3px;">
                  Quick intro for {{ $json['First Name'] || 'you' }}
                </div>
              </td>
            </tr>
            <tr>
              <td style="padding:28px 24px 8px 24px;" class="text">
                <div style="font:16px/1.6 -apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Arial,sans-serif;color:#111827;" class="text">
                  <p style="margin:0 0 14px 0;">
                    Hi {{ ($json['Civility'] ? ($json['Civility'] + ' ') : '') + ($json['First Name'] || $json['Full Name'] || 'there') }},
                  </p>
                  <p style="margin:0 0 14px 0;">
                    {{ $json['iceBreaker'] || 'Saw your recent work and had a quick idea that might help your team.' }}
                  </p>
                  <p style="margin:0 0 14px 0;">
                    {{ $json['elevatorPitch'] || 'We help teams ship faster with fewer rollbacks by tightening CI and monitoring.' }}
                  </p>
                  <table role="presentation" cellpadding="0" cellspacing="0" style="margin:18px 0 8px 0;">
                    <tr>
                      <td>
                        <a href="{{ $json['Company Website'] ? ('https://' + $json['Company Website'].replace(/^https?:\/\//,'')) : '#' }}"
                           style="display:inline-block;background:#111827;color:#ffffff;text-decoration:none;padding:12px 18px;border-radius:10px;font:600 14px/1 -apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Arial,sans-serif;"
                           class="btn">
                          {{ ($json['First Name'] ? ('Quick 15–20 min chat, ' + $json['First Name']) : 'Quick 15–20 min chat') }}
                        </a>
                      </td>
                    </tr>
                  </table>
                  <p style="margin:6px 0 16px 0;color:#374151;">
                    {{ $json['callToAction'] || 'Open to a quick call? I can do a free audit and prove value in 2 weeks.' }}
                  </p>
                  <p style="margin:0 0 6px 0;color:#6b7280;" class="muted">
                    PS — {{ $json['ps '] || $json['ps'] || 'worth a brief pipeline audit?' }}
                  </p>
                </div>
              </td>
            </tr>
            <tr>
              <td style="padding:0 24px;">
                <hr style="border:none;border-top:1px solid #e5e7eb;margin:8px 0 0 0;" class="divider">
              </td>
            </tr>
            <tr>
              <td style="padding:16px 24px 22px 24px;">
                <table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="font:13px/1.5 -apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Arial,sans-serif;color:#4b5563;">
                  <tr>
                    <td style="padding:2px 0;">
                      <span style="display:inline-block;padding:6px 10px;border-radius:999px;background:#f3f4f6;" class="chip">
                        {{ $json['Full Name'] || (($json['First Name']||'') + ' ' + ($json['Last Name']||'')) || 'Your contact' }}
                      </span>
                      <span style="display:inline-block;padding:6px 10px;border-radius:999px;background:#f3f4f6;margin-left:6px;" class="chip">
                        {{ $json['Title'] || 'Professional' }} @ {{ $json['Company Name'] || $json['Company Legal Name'] || 'Company' }}
                      </span>
                    </td>
                  </tr>
                  <tr>
                    <td style="padding:2px 0;">
                      <span style="display:inline-block;padding:6px 10px;border-radius:999px;background:#f3f4f6;" class="chip">
                        {{ $json['Industry'] || 'Industry' }}
                      </span>
                      <span style="display:inline-block;padding:6px 10px;border-radius:999px;background:#f3f4f6;margin-left:6px;" class="chip">
                        {{ $json['Company Location'] || 'Location' }}
                      </span>
                    </td>
                  </tr>
                  <tr>
                    <td style="padding:2px 0;">
                      <a href="{{ $json['Company Website'] ? ('https://' + $json['Company Website'].replace(/^https?:\/\//,'')) : '#' }}"
                         style="color:#4f46e5;text-decoration:none;">{{ $json['Company Website'] || 'website' }}</a>
                      &nbsp;•&nbsp;
                      <a href="{{ $json['Company LinkedIn'] || $json['Profile'] || '#' }}"
                         style="color:#4f46e5;text-decoration:none;">LinkedIn</a>
                      &nbsp;•&nbsp;
                      <span>{{ $json['Company Phone'] || '' }}</span>
                    </td>
                  </tr>
                  <tr>
                    <td style="padding:6px 0;color:#6b7280;">
                      {{ $json['Company Summary'] || 'Helping customers succeed with modern software.' }}
                    </td>
                  </tr>
                </table>
              </td>
            </tr>
          </table>
          <div style="max-width:640px;margin:12px auto 0 auto;text-align:center;font:11px/1.6 -apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Arial,sans-serif;color:#9ca3af;">
            You’re getting this because someone reached out 1:1 — no list.
          </div>
        </td>
      </tr>
    </table>
  </body>
</html>

In the Options field, click “Add option”. From the list that appears, select “Append n8n Attribution”. You’ll see it added to your options panel; toggle it off.
This prevents n8n from automatically adding the line “This email was sent automatically with n8n” to your messages.

Finally, click “Execute node” to send your first personalized email.

Step 7 — Automate the workflow

Once you've tested the entire workflow and confirmed that everything is functioning properly, you can replace the manual trigger with a scheduled trigger. This allows n8n to automate the process, so you won't need to run the workflow manually in the future. By using a Cron trigger, you can set the workflow to execute on a regular schedule, such as every morning at 8 AM.

Conclusion.

In this guide, I showed you the process of feeding data into a workflow, personalizing each row of information, and outputting it in the provided spreadsheet. This is just a starting point, an introduction to the world of automated personalized cold emails. We can take this workflow a step further by adding several nodes that allow us to get recent posts of our prospects. This will help us identify more trigger words to provoke responses.

As you advance beyond the basics, focus on the technical foundations that keep personalization effective at scale; Clean data practices, robust email authentication, and strict compliance with relevant regulations, such as GDPR and CAN-SPAM, are essential for ensuring that your messages do not get misclassified as spam. When it comes to sending practices, it's advisable to gradually warm up new mailboxes by beginning with small volumes of emails that mimic human-like behavior. This strategy helps prevent your messages from being flagged as junk.

If you’d like help building more sophisticated workflows, perhaps pulling recent LinkedIn posts or other triggers into your outreach, I’m happy to help. Personalization done right is a competitive advantage, and investing in the tools and techniques to do it at scale will set you apart from peers who still do one‑size‑fits‑all blasts and time‑consuming manual research.

Step-by-Step Guide: Deploying a Full-Stack App on AWS EC2.

Ukagha Nzubechukwu — Wed, 01 May 2024 16:03:27 +0000

Introduction

After building an application, deploying it to a cloud service is crucial in making it accessible to your users. Amazon offers a service called Amazon Elastic Compute Cloud (EC2), which provides scalable and low-cost virtual servers in the cloud.

With EC2, you can easily customize the various specs of your virtual server, such as operating systems, CPU, memory, storage, and other features. You also control your security and network settings, which ensures that data is only accessible to authorized users. EC2 is an ideal choice for hosting applications of different sizes and complexities.

In this guide, you will learn how to deploy a full-stack application that comprises a Typescript Next.js client and Node.js server to Amazon EC2. You will cover steps to:

Set up an AWS EC2 instance.
Install PostgreSQL and create a database.
Deploy your application code onto the instance.

Additionally, this guide will cover how to configure your network and security settings for optimal performance and safety. Let’s get started.

Prerequisites

To complete this guide, make sure you have the following requirements:

An AWS Account.
Git bash (Standalone Installer). If you need help installing Git Bash, check out this tutorial — How to install Git on Windows 10.
PostgreSQL installed. Follow this tutorial — How to Install PostgreSQL 15 on Windows Postgres for guidance on how to install PostgreSQL.
Some familiarity with PostgreSQL and basic Linux commands. However, if you don't have any prior experience, don't worry. This guide is beginner-friendly. But, If you are interested in learning more about these topics, you can acquire the necessary knowledge through the following courses:
- Learn PostgreSQL Tutorial - Full Course for Beginners
- Introduction to Linux and Basic Linux Commands for Beginners.

Step 1: Launch an EC2 instance.

In this step, you will set up and launch an AWS EC2 Ubuntu instance.

The Ubuntu operating system is a popular choice when setting up an AWS EC2 instance. It is open-source and comes with no licensing fees. Ubuntu supports a vast range of software and has a thriving community that makes it easier to find help.

To start, log in to your AWS console. Next, search and select EC2 using the search bar.

Click on Launch instance to begin set up and launch your AWS EC2 instance.

To proceed, provide a unique and descriptive name for your instance.

Next, in the Application and OS Images section, select Ubuntu.

By default, the Instance type section is preselected for you. The default option is sufficient for this guide and will save you money. But if you want more resources and power, you can select a higher instance type, which will come at a higher cost.

In the Key pair section, click Create new key pair to generate a new key pair. This key pair will be used to securely connect to your AWS EC2 Ubuntu instance using SSH.

You will next be prompted to set up your Key pair. Enter a Key pair name, keep the default options, and click on Create key pair.

Once you click Create key pair, your Key pair will be downloaded automatically.

In the Network Settings section, leave the first option as default. Beside the SSH checkbox, click the dropdown menu to select the location from which you want to connect to your instance.

There are three options available in the dropdown menu:

The 0.0.0.0/0 option allows you to connect to your instance from any machine.
The custom option provides greater control over who and where your instance can accept connections.
The My IP option allows you to only connect to your instance from your local machine.

Finally, enable the HTTP and HTTPS options to ensure your instance is accessible via the web.

Keep the default options for the Configure storage and Advanced details sections, as they offer the best performance for your EC2 instance. However, if you have specific requirements, you can customize them.

Click the Launch instance button to launch your instance.

You have successfully launched your instance. Next, you will establish a secure SSH connection to your instance.

Step 2. Connect to your AWS EC2 Ubuntu Instance

You will establish a connection to your AWS EC2 Ubuntu instance using SSH. SSH ensures secure and encrypted access to your instance. To authenticate the connection, you will use the key pair you created earlier to verify your identity and access the instance.

Navigate to your EC2 dashboard and click on Instances (running) in the resources tab to access your running instance(s).

After navigating to the Instances page, click on the instance that you created recently.

Next, click on the connect button located in the top-right corner of your screen. This will take you to the Connect to Instance page, where you can connect to your instance via several options.

Select the SSH client tab to review your connection details.

To connect to your instance, open Git Bash, navigate to the directory where your Key pair was downloaded, and execute the following commands:

Press CTRL + C to copy and CTRL + Shift + Insert to paste in Git Bash.

chmod 400 "your-key-pair-name"
ssh -i "your-key-pair-name" ubuntu@ec2-*-*-*.eu-north-1.compute.amazonaws.com

After executing the command, you will get the following prompt:

The authenticity of host 'ec2-*-*-*-*.eu-north-1.compute.amazonaws.com (*.*.*.*)' can't be established. ED25519 key fingerprint is SHA256:<some-text>. This key is not known by any other names. Are you sure you want to continue connecting (yes/no/[fingerprint])?

Type yes and hit the ENTER button to proceed.

If connected, your current directory should change to:
ubuntu@ip-your-ip:~$

You have now successfully connected to your AWS EC2 Ubuntu instance. The next step is to update and upgrade your instance to ensure you have the latest security patches and features.

Step 3: Update and Upgrade your instance.

Here, you will update and upgrade your instance to ensure it is up to date with the latest updates and upgrades.

Run the following commands to update and upgrade your instance:

sudo apt update 
sudo apt upgrade

When you run the sudo apt upgrade command, you may get this message:
After this operation, 36.9 KB of additional disk space will be used. Do you want to continue?[Y/n]

Type Y and press the ENTER key to continue.

Next, you may get a prompt to upgrade the kernel. Press the ENTER button to proceed with the upgrade. Once you do that, a new prompt will appear where you will check specific values.

To continue, navigate the list of services using the ARROW keys. Use the SPACEBAR key to mark each unchecked checkbox. Once all the checkboxes are marked, press ENTER to complete the process.

Your instance is now ready for use. Next, you will set up PostgreSQL.

Step 4: Setting up a PostgreSQL Database.

In this step, you will install, and set-up PostgreSQL for your application on your EC2 instance. While you could have used other databases and saved time, being able to set up a traditional, relational database like PostgreSQL in a Linux environment is a valuable skill.

It is recommended to create a database for your application in your local environment and then transfer a copy of it to your instance, rather than creating a new database on your instance.

This approach saves time, particularly if you already have a database on your local environment. Additionally, transferring a copy of your local database ensures data accuracy, and consistency as your local database may contain a large amount of data.

Run the commands below in your local environment using the command prompt or any terminal of your choice to:

connect to postgres
create a new database, connect to it
create a table
exit

psql -U postgres
create database todo_app;
\c todo_app;
create table todo (id BIGSERIAL NOT NULL PRIMARY KEY, newItem VARCHAR(255) NOT NULL);
\q

Next, use the following command to create a backup of the newly created database in your local environment:

pg_dump -U postgres -f todo_app.pgsql -C todo_app

In the command above:

pg_dump is a CLI tool for creating database backups.
The -U flag specifies the user to connect to PostgreSQL with.
The -f flag specifies the output file, which in this case is todo_app.pgsql.
The -C flag is used to include commands for creating the todo_app database in the backup file specified by -f.

After running the pg_dump command, the todo_app.pgsql file will be downloaded in the current directory. Move the backup file to the directory where your AWS Key pair is. Your key pair will be needed to authenticate your connection and accept incoming files.

You will use the SCP protocol to move your backup file to the home directory of your Ubuntu instance. To do this, run the following command:

scp -i your-key-pair-name todo_app.pgsql ubuntu@ec2-*-*-*-*.eu-north-1.compute.amazonaws.com:/home/ubuntu/

If the transfer was successful, you should get this message:
todo_app.pgsql 100% 2372 11.3KB/s 00:00

Now that you have successfully created and transferred a copy of your local database to your instance. Head back to Git Bash to set up PostgreSQL in your instance.

If you get logged out of your session, run the SSH command again to log back in.

ssh -i "your-key-pair-name" ubuntu@ec2-*-*-*.eu-north-1.compute.amazonaws.com

To install PostgreSQL on your instance, use the command:

sudo apt install postgresql postgresql-contrib -y

After installing PostgreSQL, a default user called postgres is created. You can view the user by running the command:

sudo cat /etc/passwd | grep -i postgres

Output:
postgres:x:115:123:PostgreSQL administrator,,,:/var/lib/postgresql:/bin/bash

To set up PostgreSQL, switch to the postgres user:

sudo -i -u postgres

If connected, your current directory should change to:
postgres@ip-your-ip:~

Create a new user using the command:

createuser --interactive

You will be prompted for the following information. Enter your answers accordingly:

Enter name of role to add: ubuntu
Shall the new role be a superuser? n
Shall the new role be allowed to create databases? y
Shall the new role be allowed to create more new roles? n

Exit the postgres user using the command:

exit

Use the command below to create a password for the ubuntu user.

 psql -d postgres
 ALTER USER ubuntu PASSWORD 'password';
 \q

If you are curious why you can connect to your database using psql -d <database> without specifying a user, this happens because PostgreSQL will try to connect with the same user as your logged-in user, which in this case is ubuntu. If the user ubuntu exists in Postgres, the connection will go through without being prompted for a password, as PostgreSQL uses peer connections for local connections.

Now, create a database and import the contents of the backup database file you created in your local environment:

psql -d postgres
create database todo_app;
\q 
psql todo_app < /home/ubuntu/todo_app.pgsql

Output:
. . . ALTER TABLE

To connect to your todo_app database, execute the command:

psql -d todo_app
select * from todo;
\q

Your PostgreSQL database is ready, you can proceed to set up your application.

Step 4: Set up your application

Now, you will clone the application code from GitHub and get your server and client ready for deployment.

Server set up

To install Node.js run the command:

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs

You may be prompted by the kernel, press ENTER to proceed.

Clone the application into your Ubuntu instance:

cd ~
git clone https://github.com/backendbro/todo-app-ubuntu.git

Install the dependencies required by the server:

cd todo-app-ubuntu/server 
npm install 
sudo npm install -g nodemon

When working in a production environment, it's not recommended to run node server.js directly. This is because the Express server will shut down whenever you exit your instance. To avoid this, you can use PM2. PM2 is a process manager that ensures your Express server stay up and running at all times.

To install PM2 globally, run the command:

sudo npm install pm2 -g

Before starting your server, compile your Typescript server with:

npm run build

Now, start your server using PM2 by running the command:

cd ~
pm2 start /home/ubuntu/todo-app-ubuntu/server/dist/server.js --name todo-app

Next, configure PM2 to automatically restart your Express server in case of a crash or reboot using the command:

pm2 startup

Output:
[PM2] Init System found: systemd [PM2] To setup the Startup Script, copy/paste the following command: sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u ubuntu --hp /home/ubuntu

To complete the setup for PM2, copy and run the startup script.

Ensure that you copy the script from your instance as yours may differ. The command below is only an example to guide you on what to copy and run.

sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u ubuntu --hp /home/ubuntu

Finally, save your current list of running processes:

pm2 save

Client set up

After starting the server, install the necessary dependencies and run the build command to prepare the client.

cd ~ 
cd todo-app-ubuntu/client 
npm install
npm run build

In the next step, you will configure Nginx to serve your client so it can be accessible on the web.

Step 5: Installing and Configuring Nginx

In this step, you will configure Nginx to serve your client side. You will need a domain name to complete this step. Just in case you have no money to spare, check out this video — Free Domain Name — Use Anywhere, No Credit Cards, NO CATCH! for help on how to get a domain name free of cost.

You can find your Public IPv4 address on your instance dashboard to set up your domain.

To get started, execute the command below to install and enable Nginx:

cd ~
sudo apt install nginx -y
sudo systemctl enable nginx

To set up an Nginx server block, navigate to the sites-available folder.

cd /etc/nginx/sites-available

When you run the ls command to list the files in the current directory, you'll find a server block named default which is responsible for handling requests that don't match any other server blocks in the sites-available directory.

To view the default server block, open http://<your-ec2-instance-Public-IPv4-address> or http://<your-domain-name> in your web browser.

You can use the default server block as a template to create your server block. To do this, run the following command:

sudo cp default todo_app

Open the todo_app server block for configuration:

sudo vi todo_app

To begin configuring the todo_app server block, press the I key on your keyboard to enter INSERT mode. This will enable you to type in the required changes. Replace the contents in the first server block with the following:

server {
      listen 80;
      listen [::]:80;

     root /var/www/html;

      # Add index.php to the list if you are using PHP
     index index.html;

     server_name your-ec2-public-ipv4-adddress your-dmain-name.com;

     location / {
          try_files $uri $uri/ =404;
    }


   location /api/v1/todo {
            proxy_pass http://localhost:4000;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection 'upgrade';
            proxy_set_header Host $host;
            proxy_cache_bypass $http_upgrade;
        }

}

Once you have made the changes, press the esc key to exit INSERT mode. Next, type :wq and press ENTER to exit the vim terminal.

Make sure to memorize the sequence for inserting values and exiting in vim, as you will need it later.

Now, enable the new server block by running the command:

sudo ln -s /etc/nginx/sites-available/todo_app /etc/nginx/sites-enabled/
sudo systemctl restart nginx

Use the command below to move your client build files to the root directory specified in the todo_app server block:

sudo mv /home/ubuntu/todo-app-ubuntu/client/dist/* /var/www/html

Now, you should be able to access your website using http://<your-Public-IPv4-address> and http://<your-domain-name>.

But, at the moment you won’t be able to make request to the Express server, because the Express server cannot access its environment variables. In the next step, you will set up your environment variable.

Step 6: Setting up environment variables

In this step, you will configure your environment to allow your Express server to access its PORT number and the PostgreSQL database.

Create a .env file:

cd ~
sudo vi .env

Copy and paste in the following environment variables into the .env file

PORT=4000
DB_USER=ubuntu
DB_HOST=localhost
DB_PASSWORD=password
DB_DATABASE=todo_app
DB_PORT=5432
NODE_ENV=production

If you must enter a different value in the .env file, ensure there are no space(s) between the variable name, equal sign and your variable value.

Moving on, open the .profile file

sudo vi /home/ubuntu/.profile

Enter the following command below into the .profile file to ensure your environment variables is set at all times, even when your instance reboot or crash.

Make sure to enter the command at the bottom of the .profile file

set -o allexport; source /home/ubuntu/.env; set +o allexport

Visual illustration:

For this change to take effect, restart your instance:

sudo reboot

You will be logged out from your Ubuntu instance. Re-connect to move on to the next step.

After setting up your environment variables, you will enable a firewall to filter specific connections.

Step 7: Enable firewall

In this step, you will enable the firewall to filter the type of requests that can reach your Ubuntu instance.

To allow SSH, HTTP, and HTTPS requests, run the commands:

sudo ufw allow ssh
sudo ufw allow http
sudo ufw allow https

To apply your changes, use:

sudo ufw enable

After running the sudo ufw enable command you will receive this message:
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Type y and press ENTER.

After filtering specific requests, the next step is to enable SSL. This will ensure your website is secure, and visitors can access it without encountering pesky security warnings on their browsers. With SSL, your site will be safe and trustworthy.

Step 8: Enable SSL

In this step, you will generate an SSL certificate with Certbot and configure Nginx to redirect HTTP traffic to HTTPS.

Install Certbot by running the command:

sudo snap install --classic certbot

Enable certbot using:

sudo ln -s /snap/bin/certbot /usr/bin/certbot

Configure Cerbot for Nginx, with the command:

sudo certbot --nginx

When running the certbot configure command, you will be prompted for the following. Here's how you should answer:

Enter email address ... ? valid-email@email.com
Please read the Terms of Service at ... ? Y
Would you be willing, once your first certificate is successfully issued... ? N
Which names would you like to activate HTTPS for? ... ? 1

Your SSL certificate has been successfully set up. Now, head over to your website to view it.

Conclusion.

By following this guide, you deployed a full-stack Next.js and Node.js application to an AWS EC2 Ubuntu instance. However, It is important to note that in larger applications, you might need to take a different approach where you may have to split your application services into two or more instances.

In this guide, you covered the fundamental steps involved in the process. Firstly, you learned how to set up and configure an AWS instance. Next, you learned how to set up PostgreSQL on your AWS EC2 Ubuntu instance. You created a new Postgres user, and a new database. You also learned how to set up and configure Nginx and PM2 as a reverse proxy and process manager, respectively. In addition, you learned how to create an SSL certificate, which is crucial for secure and encrypted communication between your application and the user's web browser.

Although some details may vary depending on your specific application, this guide provides a solid foundation for deploying an application on AWS EC2. With this knowledge, you can confidently deploy your application on AWS and take advantage of its scalability, reliability, and security. Happy deployment 😊

How to fix the “aws-elasticbeanstalk-ec2-role” error in AWS Elastic Beanstalk.

Ukagha Nzubechukwu — Mon, 01 Apr 2024 09:38:35 +0000

If you're reading this, chances are you have encountered the "aws-elasticbeanstalk-ec2-role" error. This error message is usually caused by missing security configurations, associated with the EC2 instance that Elastic Beanstalk launches.

In this guide, you will learn how to troubleshoot and fix the "aws-elasticbeanstalk-ec2-role" error.

Prerequisites

To complete this guide, you'll need the following:

An AWS account.
Some familiarity with AWS IAM and AWS Elastic Beanstalk. If you are not familiar with the following topics, check out these tutorials — Introduction to AWS Elastic Beanstalk and Lab 1 Introduction to AWS IAM.

Understanding the "aws-elasticbeanstalk-ec2-role" error

It's important to understand the nature and cause of the error before attempting to solve it.

In AWS, instance profiles are used to give permissions to EC2 instances. If an instance profile lacks the necessary permissions or configurations, the associated EC2 instance will not have access to AWS resources like S3, RDS, DynamoDB, and much more.

An instance profile is a container for an AWS IAM role that you can assign to an EC2 instance.

The "aws-elasticbeanstalk-ec2-role" error occurs while setting up an environment in the Elastic Beanstalk console. The error originates when you choose the Create and use a new service role option and do not provide an EC2 instance profile with the necessary permissions. It's important to note that this error is due to AWS security guidelines.

Way back, AWS services like EC2 were allowed to create a default “aws-elasticbeanstalk-ec2-role” instance profile on the spot, but this practice has been changed in line with security best practices.

How to fix the “aws-elasticbeanstalk-ec2-role” error

To fix the "aws-elasticbeanstalk-ec2-role" error, create an instance profile and assign it the necessary roles and permissions.

Step 1. Create a new role: In this step, you will create a role.

To create a role, visit the IAM page.

In the left-hand corner, under the Access management dropdown, click Role to create a role.

Once directed to the Roles page, click Create role.

To continue, keep the default Trusted entity type option.

In the Service or use case field, select EC2 and click Next to add permissions.

Step 2. Add permissions: After creating a role, you need to assign permissions to define the actions that the EC2 instance launched by Elastic Beanstalk can perform on AWS resources.

Search and select the following permissions listed below:

AWSElasticBeanstalkWebTier
AWSElasticBeanstalkWorkerTier
AWSElasticBeanstalkMulticontainerDocker

Once completed, click Next.

Step 3. Review your details: Once directed to the review page, enter a role name.

Scroll down to add a tag name, although this is optional.

Once you have filled out all the required information, carefully review your role details. If you are satisfied with them, click Create Role to complete the process.

You have successfully created an instance profile. Now, verify the solution by setting up an environment in Elastic Beanstalk.

Step 4: Setting up an Elastic Beanstalk environment: Now that you have created an instance profile for the EC2 service. Set up an Elastic Beanstalk environment.

To ensure this guide stays focused on the intended subject matter, I will not cover all the steps required to set up an Elastic Beanstalk environment. I will proceed directly to the 'configure service access' page. If you need guidance on how to set up an Elastic Beanstalk environment, I recommend checking out this video — Deploy a Web Application Using Elastic Beanstalk

In the "configure service access" page, select Create and use new service role. In the EC2 instance profile, field select the newly created instance profile.

Once you have filled out the other fields on the following pages, you can proceed to create your environment.

Viola! The solution worked!

Conclusion

In this guide, you learned how to fix the "aws-elasticbeanstalk-ec2-role" error in AWS Elastic Beanstalk. By understanding the causes of this error, such as misconfigured IAM roles or insufficient permissions, you can take appropriate steps to rectify this issue anytime it comes up.

If you need any more help with debugging, don't hesitate to ask. Happy debugging 🛠️👩🏻‍💻, and have a fantastic day!

Boost your learning with Glasp: A Comprehensive Guide.

Ukagha Nzubechukwu — Tue, 05 Mar 2024 12:43:05 +0000

Reading content online has become an integral part of our daily routine, especially in today's digital world. Whether it's staying up-to-date with the latest news about our favorite celebrities or researching various topics of interest, the internet provides us with a vast range of written and visual content to consume. However, organizing, retaining, and assimilating all this information can be challenging. This is where Glasp comes in handy.

Glasp is an online tool that allows you to highlight and take note of important passages that you find meaningful while learning. With the ever-increasing amount of online content, Glasp aims to improve our online learning experience by providing an efficient way to organize and share important information.

In this article, we will provide you with a step-by-step guide on how to use Glasp to boost your learning. So, let's get started!

Prerequisite

Make sure that you have the following to get the most out of this guide:

A desktop or laptop.
A web browser.
A cup of coffee.

An Introduction to Glasp

What is Glasp

Glasp stands for Greatest Legacy Accumulated as Shared Proof. It's a free and open-source browser extension.

Glasp highlighting and note-taking feature

Glasp allows users to highlight and note important passages from online content such as articles, PDFs, and more. Its user-friendly interface and customizable settings make it easy to use. Additionally, every highlight preserves essential metadata such as the headline, URL, excerpt, and tags. Glasp also provides users with transcripts of YouTube videos, which they can use to leave notes at important timestamps. This feature allows users to pick up where they left off easily.

Glasp is a breath of fresh air on how users consume content online, allowing them to quickly find, highlight, and save important parts of lengthy articles, documents, and other publications. Glasp takes highlighting and note-taking a step further by giving users the option to keep their collections private or share them publicly with others via social media platforms.

Glasp community building

Glasp fosters collaboration and community building by recommending online groups and collections based on your activity. Users can also search through and follow other public Glasp collections for research or leisure reading.

Glasp tag system

When there are many articles to keep track of, it can become overwhelming to manage them all. Glasp offers a tag system to help you stay organized. Once you highlight an article, you can add as many tags as you want to help categorize it. This makes it much simpler and more efficient to keep track of the information you need.

Glasp user profile

Glasp offers its users an easy-to-navigate profile page that allows them to easily access their highlights, notes, highlighted articles, tags, views, and much more.
The user's profile page features a green panel on the left-hand side, which enables them to keep track of their daily highlights. Some users find this feature motivating as it allows them to keep streaks, while others may use it to review the articles they have highlighted so far.

Glasp cross-platform compatibility

Glasp allows users to easily import and export their highlights and notes. If you have any highlights or notes saved on your Kindle or any other e-reading platform, you can easily import them into Glasp. Additionally, you can download your activity on Glasp by exporting it as a file. You have the option to download your highlights and notes as a file in various formats such as Text, CSV, HTML, MD, and PNG (image). You can choose to download your highlights and notes by article or all at once.

All in all, Glasp is the ultimate companion for anyone looking to boost their reading or research skills.

Installing Glasp.

Let's move on to the installation of Glasp.

Visit the Glasp website to download the installer.
Choose your preferred web browser for installing Glasp.

Since I use an HP laptop with Windows installed, I will select "Install on Chrome"
Once you click "Install on Chrome" you will be directed to the Google Chrome extension store.
Moving on, click on the "Add to Chrome" button to download the Glasp extension.
To start the installation process, click on the “Add extension” button.
Wait patiently while Glasp is being downloaded.

Once the download process is finished, Glasp will automatically install itself.
Hurray! You have successfully installed Glasp. Now, let's move on to setting up a Glasp account.

Setting up Glasp

To sign up, visit the Glasp website and click the Sign-up button in the top right corner, or log in if you already have an account.
To finish the registration process, click on the "Continue with Google" button.

Make sure to enable pop-up functionality in your web browser to allow Glasp to complete the registration process.
Voila! You have successfully set up a Glasp account.

Glasp in action

In this section, we will go over the steps to use Glasp for highlighting, taking notes, and much more.

Highlighting

We will use this blog post to illustrate how to highlight using Glasp.

Make sure you are viewing this blog. Although you can choose any online content you prefer.
Before highlighting, open the Glasp sidebar by clicking the extension tab on Google Chrome.

Proceed by selecting the Glasp extension. Ensure to click only once

I used this method to open the Glasp sidebar because the icon may not always appear on everyone's browser, and no, it's not a bug. It's most likely due to your browser.
To start highlighting, left-click on your mouse or mousepad and drag your cursor over the text that you want to highlight. A pop-up will appear with several options, including highlighting colors, adding notes, creating a Quoteshot, and sharing on Twitter.
To continue, highlight your selected passage by clicking a color option.
Head over to the Glasp sidebar to view your highlighted text.
In addition to highlighting, Glasp offers a range of other features. If you hover your mouse over any highlighted text in the Glasp sidebar, an ellipsis menu will appear in the top right corner. This menu provides you with access to a variety of options that can help you to better manage your highlighted content.

To access the list of available actions on your highlighted text, click on the ellipsis.
You can use the "Create Highlight Image" feature to generate an image from your highlighted text.
Glasp offers several image customization options, including orientation, background color, font style, a download button, and the ability to share on social media platforms.

Note-taking

This section will demonstrate the two ways to take notes using Glasp.

Using the Elipsis
- Click the ellipsis in the top right corner of the highlighted text in the Glasp sidebar to reveal a list of options.
- To add a note, click the "Add a Note" button.
- Add a note that best describes the highlighted text.
Using the Pop-up palette
- Left-click on your mouse or mousepad and drag your cursor over the selected passage to display the pop-up palette.
- To continue, click on the "Add a Note" icon.
- When you click the "Add a Note" icon, Glasp will automatically highlight the selected passage and provide an input field to enter your desired note.

Comment

To comment, use the designated input field. Refer to the screenshot below for guidance
To save your comment, click the "Save" button.

Using Glasp in PDFs

Highlighting and taking notes in PDFs using Glasp is a simple process, just like doing it on websites. However, it's important to note that Glasp can only be used on online PDFs and not on locally downloaded PDFs.

I will be using the PDF below. I understand that it may seem brainy, but it's just for illustrative purposes. I couldn't find a simpler PDF, so feel free to use any PDF of your choice.
Load Glasp on the PDF by clicking on the Glasp icon in the top-right corner.
Wait a few seconds while Glasp prepares your PDF for use.
After your page has finished reloading, you can begin highlighting by left-clicking and dragging your mouse over your selected passage.

To highlight, click on a color option.
After highlighting, you can add notes, comments, tags, or create images from the text.

Using Glasp as a YouTube companion

When it comes to learning on YouTube, Glasp makes the perfect companion. Here are some tips to help you boost your productivity and focus while learning.

I will use the YouTube video below as a case study, but feel free to choose any video you prefer
On the left-hand side, you will find a Glasp dropdown. The Glasp dropdown also provides buttons for actions such as generating an AI summary, jumping to the current time, and copying the transcript.

Click on the Glasp dropdown to review the transcript of the YouTube video.
Proceed to highlight your selected passage or timestamp.
To generate a summary of a YouTube video, click on the AI icon in the Glasp dropdown.

You will be redirected to ChatGPT where you can find your summary.

With the Glasp AI Summary, you can now get the full gist of a YouTube video in seconds.

A view of the Glasp profile

In the previous sections, we covered the steps to use Glasp. Now, head to your profile and view your activity so far.

Login into your Glasp account.
After logging in, your profile will be displayed where you can view your activity log, including highlighted articles, notes, tags, and comments.

Psst! While you weren't looking, I highlighted some more articles.

.
In the bottom left corner, you can see your activity graph. You can maintain streaks as a way to motivate yourself to learn daily.
Below your activity graph, you can find your tags. Tags help categorize your highlights and notes.
Navigate to the homepage to find exciting activities, such as viewing posts and highlights from your followed users, trending topics, and more.
You can check out the explore page on Glasp to see what others are reading in the community.

Benefits of Glasp

Easy recollection of what you learned: Glasp helps you remember what you learned previously by allowing you to highlight important passages and take notes. The act of highlighting a passage helps your memory retain that specific text, while the notes you take can serve as an excellent reference for future use. Glasp is an incredibly effective tool for boosting your learning by providing an easy and intuitive way for you to highlight and keep track of important excerpts.
Collaboration and community building: Glasp is designed to help you learn and grow by sharing and viewing other people's highlights and notes. With Glasp, you can easily broaden your horizon and catch up on what you might have missed out on. The platform offers a variety of features for sharing and viewing other users' thoughts and a comment section that enables different people to share their views on a particular piece of highlighted text or note. Using Glasp, you can collaborate with your peers, friends, and colleagues to create a learning community where everyone can contribute and learn from each other.
Increased productivity: Glasp is a tool that helps users increase their productivity while learning. With Glasp, users can stay focused on their learning material without the need to switch to other apps to take notes, which can be distracting. Once they're done learning or need to check something important, they can easily visit their profile. Glasp also provides users who learn using YouTube videos with transcripts, which allows them to easily follow along with the specific video they are watching and even highlight and take notes where necessary.
Cross-platform compatibility: Glasp is compatible with multiple browsers, enabling users to highlight, take notes, and access their profiles on any browser of their choice. Additionally, the Glasp platform is also compatible with other e-reader devices such as Kindle. Users have the option to import or export their activity on any platform they prefer, making Glasp a convenient and accessible option for users who frequently switch between devices or platforms.

Conclusion.

So far, we have learned about what Glasp is and how it can be used. We have also explored its use cases, highlighting how Glasp can boost learning and productivity. Using Glasp, you can easily highlight important passages and take notes directly on web pages. The tool makes note-taking and highlighting fun and engaging, with an easy-to-use pop-up palette and a variety of soothing colors to choose from.

Glasp is the perfect companion for YouTube, providing a transcript of the video and an AI-powered summary. Additionally, the platform offers many other features. You can view your activity on the Glasp profile, explore other topics of interest, comment on other people's highlights and notes, and learn from them.

Overall, Glasp is an excellent tool for boosting and improving how you consume, organize, and assimilate online content. I hope this guide has been helpful to you. Happy learning! 😊

Credits and Further reading

Glasp website
Glasp documentation:
- How to highlight using Glasp
- 3 best online highlighter

How To Boost Your Node.js Performance by Implementing Caching With Redis.

Ukagha Nzubechukwu — Tue, 27 Feb 2024 00:09:27 +0000

Introduction

As your application grows and attracts more traffic, it becomes increasingly important to ensure faster response times. This helps prevent users from experiencing delays and frustration while using your app, as slower response times can make you lose users and revenue. By implementing caching, you can optimize and scale your application, providing users with faster response times and a great user experience.

Storing frequently accessed data in a location (cache) that is quicker to access is an effective way to improve the performance of your Node.js application. Caching reduces the time and resources required to query the main memory (database), which in turn reduces server load and speeds up content delivery to users.

In this guide, you will learn the fundamentals of Caching and Redis. You will also learn how to implement caching in a Node.js application using Redis. This will be done with a simple blog example built with Node.js, MongoDB, Express, and Express Handlebars.

Prerequisites

To follow this guide, ensure you have the following:

A basic understanding of Node.js, Express, and Express handlebars.
An Upstash account.
A MongoDB Database (Atlas). If you're unsure how to retrieve your MongoDB Atlas connection string, check out the tutorial — A step-by-step guide: How to use MongoDB with Node.js to set up MongoDB Atlas for guidance.

TL;DR: you can find the entire code used in this guide on GitHub.

An Introduction to Caching.

What is a Caching?
Caching is the process of storing data in a cache. When we query for data from a source (main memory or a database), we have to wait for some time to get a response. But if data is stored in a fast access memory like Redis, data retrieval time can be cut in half, and we get to prevent a bottleneck caused by a large number of users trying to access the same piece of data.

Use case
Have you ever noticed that when you visit your favorite website, it always seems to know what you're interested in? Social media platforms like Facebook also use your cached information to make friend suggestions and show you posts that are relevant to your interests. By using your cached data, these websites aim to improve your user experience and make your online activities more enjoyable.

Cache internals and mechanism
Caches are designed to be small, fast, and lightweight. However, this limits their capacity to hold large amounts of data for extended periods. To ensure that they always have up-to-date information, caches work in tandem with databases. Because caches are small, it is important to regularly remove old or outdated data and replace it with fresher information. One technique used to accomplish this is Time-To-Live (TTL), which moves expired data out of the cache to make room for new data. Caching algorithms are also used to evaluate the data in the cache and determine which data has the lowest priority and should be removed.

Setting up a Cache network
When setting up a cache network, it's essential to consider the data that users frequently access. This is because you don't want to cache unnecessary information that will occupy valuable space. To achieve a high cache hit rate, a cache policy that works best for your application must be carefully implemented. For instance, the "write-through cache" policy ensures that the cache and database are updated simultaneously.

However, there is a cost associated with this policy as it may not be suitable for write-intensive applications. This is because your application will have to store data in two locations, leading to performance issues.

On the other hand, if your application is write-intensive, the "write-back cache" may be more suitable, as it only writes data to the cache at first and later updates the database. This way, data is not stored simultaneously in two locations, preventing performance issues.

It's crucial to consider the type of application you're building before selecting a caching policy and algorithm to prevent further problems in your application.

An Introduction to Redis

What is Redis
Redis is an open-source, in-memory data store that can be used as a database, cache, and message broker. Redis is well-known for its high performance, flexibility, and scalability, making it a popular choice for modern web applications.

Redis's in-memory data model allows it to store and access data directly from the server's RAM, rather than being written to disk like traditional databases. As a result, Redis offers faster data access and retrieval times and lower latency since disk I/O operation is reduced.

Redis data storage
In addition, Redis stores data using a key-value pair, where each key is a string, and each value can be any of the supported data structures.

Redis is capable of supporting a variety of data structures, including strings, hashes, lists, sets, and sorted sets, making it well-suited for real-time analytics, caching, and message passing.

Use case
Redis is a powerful tool for caching data. Its high throughput and availability make it an excellent choice for implementing caching, as it ensures a high cache hit rate. This means that frequently accessed data are served up faster, reducing the time it takes to retrieve data from the main memory (database). Redis is also used for several use cases such as chat, messaging, queues, gaming leaderboards, session stores, and much more.

Overall, Redis is a powerful and versatile tool that can help developers build faster, more scalable, and more reliable applications.

Setting up Redis.

In this guide, we will use a Redis server service named Upstash. Although other web services such as AWS Lambda, Azure Functions, and Google Cloud Functions offer Redis cache, we will use Upstash to navigate this tutorial.

To get started, visit Upstash to create an account. If you already have one, you can log in.
After setting up your account, click the "Create database" button to create a Redis database.
Fill out the form in the pop-up and click "Create" to proceed. Refer to the screenshot below for help:
Viola! we have successfully set up a Redis cache.
To retrieve your connection string; scroll down, click on the “Node” tab, and select "ioredis". Refer to the screenshot below for help.

Hover over the password tab to copy your password. Then, replace the star symbols in your connection string with your actual password.
Make sure to keep your Redis connection string safe and ready, as it will be needed in the next section when we implement application caching.

Caching in Action

To illustrate how caching improves the performance of a Node.js application, we will use a basic blog as an example. This blog has three main functionalities: creating a post, listing all posts, and viewing a post. Let's begin!

Project setup

To proceed, go to GitHub and clone this boilerplate.
After cloning the boilerplate, run the following commands in your terminal one after the other to install all the dependencies required:
```
npm i 
npm i ioredis   
```
Quick note:

ioredis is a popular Node.js client library with a simple and high-performance interface that helps developers to easily interact with Redis servers.
Create a .env file in the root directory.

Next, enter the following environment variables into the newly created file.
```
PORT = 8000 
mongodb_uri = yourMongoDBConnectionString
redis_url = yourRedisConnectionString
```
.
To ensure that the application runs smoothly, execute the following command:
```
npm run dev
```
To access the application, open your web browser and type in the following URL — localhost:8000/dashboard. This will take you directly to the dashboard.

Writing code

In the section: "Introduction to Caching", we discussed caching policies and how selecting the right one can boost an application's performance. In this example blog, we will implement the "write-through cache" policy. This policy involves storing a post in both the cache and the database simultaneously. Since blogs are generally read-intensive, this policy will be the most appropriate.

Create a folder named redis-store in the root directory. Inside the redis-store folder, create a file named redis.js for the redis connection.

Open the redis.js file and add the following code to connect to Redis.

    const Redis = require("ioredis")
    const dotenv = require('dotenv')

    dotenv.config()

    const redisClient = () => {
    const redis = new Redis(process.env.redis_url)

     redis.on("error", (err) => {
        console.log(`Redis crashed: ${err.message}`)
     })

     redis.on("connect", () => {
        console.log(`Redis started on ${redis.options.host}`)
     })

     return redis
     }

     module.exports = redisClient()

Navigate to the controller/Post.js file, and make the following changes to incorporate caching into the code.

a. First, import the Redis connection.

const Redis = require('../redis-store/redis')

b. To cache newly created post, update addPost function with provided code snippet:

const addPost = async (req,res) => {
try {
    try {
      const newPost = new Post({
        title: req.body.title,
        body: req.body.body
      });

      const post = await Post.create(newPost);

      // Caching newly created post
      await Redis.set(post.id, JSON.stringify(post), 'EX', 
      604800)
      await Redis.del("allPosts")

      res.redirect('/dashboard');
    } catch (error) {
      console.log(error);
    }

  } catch (error) {
    console.log(error);
  }
}

In the code snippet above:

We cached each post as soon as it was created.
An expiration time of either 604800 seconds or 7 days was set to expire the post from the cache.
We also deleted the "allPosts" entry from the cache because it would be outdated once a new post is added to the database.
Finally, we are redirected to the dashboard to view the newly created post.

c. Modify the viewPost function to enable the display of specific posts from either the database or cache:

const viewPost = async (req,res) => {
  try {
      let slug = req.params.id;
      let data;

      const redisData = await Redis.get(slug)
      data = JSON.parse(redisData)

      if (data === null){
        data = await Post.findById({ _id: slug });
        await Redis.set(slug, JSON.stringify(data), 'EX', 604800)
      }

      const locals = {
        title: data.title,
        description: "Simple Blog created with NodeJs, Express & MongoDb.",
      }

      res.render('post', { 
        locals,
        data,
        currentRoute: `/post/${slug}`
      });
    } catch (error) {
      console.log(error);
    }
}

In the code snippet provided:

We first check the Redis cache to see if a post matching the provided ID exists.
If it does, we return it.
However, if there is no match in the cache, we check the database for the data, cache it, and then return the post to the user.

d. Lastly, update the getPosts function to retrieve all posts from the database or cache:

const getPosts = async (req,res) => {
    try {
        const locals = {
          title: 'Dashboard',
          description: 'Simple Blog created with NodeJs, Express & MongoDb.'
        }

        const redisData = await Redis.get("allPosts")
        let data = JSON.parse(redisData)

        if (data !== null) {
            res.render('Post-crud/dashboard', {
            locals,
            data,
            layout: mainLayout
          });
        }else {

          data = await Post.find();
          await Redis.set("allPosts", JSON.stringify(data))

          res.render('Post-crud/dashboard', {
            locals,
            data,
            layout: mainLayout
          });

        }
      } catch (error) {
        console.log(error);
      }
}

In the given code snippet above.

We start by checking the Redis cache to see if there is an entry called “allPosts”.
If such an entry exists, we directly return “allPosts” from the cache.
If there is no cached data found, we retrieve “allPosts” from the database, and then proceed to cache it.
Finally, we display all the posts to the user.

Testing

Let's test the cache implementation to ensure that it works as expected.

To run your application, open your terminal and type the command
```
npm run dev
```
.
Open your browser and access localhost:8000/dashboard to begin testing.
To create a post, click on the "Create Post" button.
Provide a title and content for your post, then click “Add”.
Upon reaching the dashboard, click on your newly created post to view it.
Yay! The application is working as intended, and we have successfully created a new post.
To complete the testing phase, log in to your Upstash account to check if both the newly created post and “allPosts” are added to the cache.
After logging into your Upstash account, go to your dashboard and click on the "Data Browser" tab to access the newly added data.
Click on each entry to confirm the contents of the newly added data.
- Single post:
- All posts:

Benchmarking

The moment of truth is here. Let's see if caching improves the performance of an application. We will use the browser dev tools to compare the data retrieval time from the database vs the cache.

Without Caching:

In this section, we will comment out all the code blocks where caching was implemented. Then, we will proceed to create a post, retrieve all posts, and view a single post.

All posts: It took 635 milliseconds to retrieve all the posts from the database and return them to us.
Single post: It took the database 267 milliseconds to return a single post.

With caching:

Let's uncomment the caching logic to compare data retrieval time.

Make sure to delete your cached data

All posts: Redis returned all cached posts in 193 milliseconds.
1. Single post: It took Redis 193 milliseconds to return a single cached post.

Conclusion

In this guide, you have learned what caching is, its benefits, concepts and how to integrate Redis as a caching solution in a Node.js application. However, we used a small-sized application to illustrate how caching works, so the data retrieval time was not too significant. In larger applications, caching can make a considerable difference in performance.

This guide also discussed the significance of selecting the right caching policy that fits into your application to minimize the load on your backend systems. It also stressed the importance of integrating cache expiration and invalidation mechanisms to ensure data accuracy and freshness.

By leveraging Redis, developers can significantly reduce response times and minimize database loads. Caching not only improves the speed of data retrieval but also reduces the workload on the server, leading to enhanced scalability and efficient resource utilization.

As your application grows, understanding and implementing caching with Redis in Node.js becomes a valuable skill. By following the steps outlined in this guide, you can optimize your application, deliver faster response times, and ultimately provide a more satisfying and seamless user experience.

I hope this guide was easy for you to follow. Happy Caching! 😊

Resources

The complete code can be found here

A step-by-step guide: How to create and publish an NPM package.

Ukagha Nzubechukwu — Fri, 02 Feb 2024 07:08:00 +0000

NPM (Node Package Manager) packages are an essential component of Node.js. They allow developers to share their solutions with the wider Node.js community. NPM packages consist of reusable blocks of code that can be easily integrated into a project with a single command. By utilizing NPM packages, developers can avoid reinventing the wheel and focus on building.

Each NPM package is identified by a unique name and version number, allowing developers to specify and install specific versions of packages in their projects.

NPM packages include a wide range of tools such as frameworks like Express or React, libraries like jQuery, and task runners such as Gulp, and Webpack.

In this guide, you will learn how to create and publish an NPM package. Let’s get to it.

Prerequisites

To follow the steps detailed in this article, you must have the following:

Basic understanding of Node.js
Node.js installed
An NPM registry account
A code editor, preferably Visual Studio Code

What is NPM?

NPM stands for Node Package Manager. It is the default package manager of Node.js. NPM provides two main functionalities:

NPM CLI: The NPM CLI, also known as 'npm', is a command-line utility that enables developers to install, manage, and publish packages.
NPM Registry: is a repository where developers can publish both public and private packages, making them accessible to others.

Packages are simply JavaScript projects.

NPM is the biggest JavaScript package manager. As of the time of writing this article, there are over 2.6 million packages available on the official NPM registry, which range from small utility packages to large-scale frameworks. These packages have been downloaded over 216 billion times.

This success can be attributed to Node.js' active and thriving ecosystem.

In Node.js, every project contains a metadata file named package.json at its root, which is created and maintained by NPM. This file contains vital information about a project, including its name, version, description, author, license, dependencies, and scripts. The package.json file serves as a central configuration file for Node.js projects and is crucial in managing dependencies.

Dependencies are packages installed in a Node.js project.

Additionally, NPM also provides some quintessential commands to do several tasks such as initializing a project, installing a package, and publishing a package. The most common commands include npm init, npm publish, npm install

NPM is critical in the Node.js ecosystem, as it promotes collaboration, solution sharing, faster development, and better software quality. It has become a must-have tool for Node.js developers and is widely used in open-source and enterprise projects.

How to create an NPM package

Before following the steps in creating an NPM package, it is recommended to decide on a name for your NPM package first. Do well to visit the NPM registry to confirm the availability of your desired name.

If your desired name is taken, consider choosing a different name. Attempting to use a name that is already taken (or something similar) will cause Node.js to throw an error.

For example: If a package named rgbcolorpicker already exists, you won't be able to publish a package with the name rgb-color-picker. Make sure to choose a unique and available name for your package.

However, if you're still keen on using the taken name, you can publish the package as a scope package. More information on how to do this will be provided later.

Now that you have your package name. Let’s continue:

Setting up an account

First, create an account on the NPM registry website. If you already have an account, log in.

Keep your credentials safe as they will be required to publish your package.

Project structure

Create the following files and folders required for this project:

My-First-Package  
└─ main.js

Below is a visual illustration:

Project initialization

Open your terminal, navigate to the root of your working directory, and initialize your project by running this command:

npm init

You will prompted by npm to provide certain information to generate a package.json file.

The importance of a package.json file in an NPM package cannot be overstated.

To assist you in creating the package.json file, here is a guide on how to enter the necessary information:
- package-name: Here, enter your selected package name. Ensure it is in lowercase and make sure to remove any trailing spaces.
- version: It's recommended to keep the initial value and update the version of the package as you make changes.
- description: Describe your package.
- entry point: This is the entry point of your package. Keep the initial value unless you plan on using a different file as your entry point.
- test command: If you have any test commands for your package, enter them here. Leave this field blank if you have none.
- git repository: Enter the link to the Git repository where this package is located.
- keywords: Provide relevant keywords such as "library", "framework", or "task-runner" to help others easily find your package.
- author: Enter your name or alias.
- license: Here, enter a license if you have one. If not, leave this field blank.

Here is a visual representation that shows how to correctly enter your information:

Writing your code

Open your main.js file and insert the provided code snippet:

function generatePassword(length, includeUppercase, includeNumbers, includeSpecialChars) {

    if (!length || typeof length === "string"){
     return new Error ("Please provide password length")     
    }

    const lowercaseChars = 'abcdefghijklmnopqrstuvwxyz';
    const uppercaseChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    const numberChars = '0123456789';
    const specialChars = '!@#$%^&*()_-+=<>?/{}[]';

    let validChars = lowercaseChars;
    let password = '';

    if (includeUppercase) validChars += uppercaseChars;
    if (includeNumbers) validChars += numberChars;
    if (includeSpecialChars) validChars += specialChars;

    for (let i = 0; i < length; i++) {
      const randomIndex = Math.floor(Math.random() * validChars.length);
      password += validChars[randomIndex];
    }

    return password;
  }

module.exports = generatePassword

In the code snippet above:
- The generatePassword function is designed to create a password and requires four arguments to run. The first argument is the desired length of the password. The remaining arguments are optional and are used to determine if the password should include uppercase letters, numbers, or special characters.
- The function is then exported so others can access it.

Test your package

The next step is to test the password-generator package to ensure it works as intended.

Navigate to your terminal and enter the command:

npm link

The npm link command allows you to create a symbolic link between a package and the global npm registry, making it accessible to other projects on your machine without needing to install it. This is particularly useful during development, as it allows you to quickly test changes without having to publish and update the package each time you modify.

Create a new folder and file to require the password-generator package

Test-Folder
└─ test.js

Make sure to navigate to the Test-Folder working directory in your terminal and run the commands sequentially

npm init -y 
npm link <packagename>

To initialize a directory or folder, you can use the npm init command. By adding the -y flag, you can skip the prompts and save time. The test-folder is specifically used for testing, so there is no need to spend time providing any necessary information.

The npm link <packagename> command will add the specified package to your project

The npm link <packagename> command created a node_modules folder. This folder holds packages installed by npm. To find your package, navigate to the corresponding folder inside node_modules

Open the test.js file and require the package.

const passwordGen = require('backendbro-password-generator') 

const password = passwordGen(10, true, false, true) 
console.log(password)

To complete the testing process, execute the command

node test.js

Voila! The package works as suppose. Let’s continue by publishing to the NPM registry.

Publishing to the NPM Registry

After testing your NPM package, you can publish it to the NPM registry. Here's a simple guide to follow:

Login to the NPM registry:

To get started, you need to create an account. If you already have one, log in.

Publish:

Open your terminal, navigate to your package directory, and run the command:

  npm login

You will be redirected to the NPM registry. Enter the One-Time Password (OTP) sent to your email address to complete the authentication process.

To publish your package, enter the command provided below:

npm publish

Yay! Your package has been successfully published to the NPM registry. You can now search for it on the registry.

Publishing Scoped Packages

In previous sections, we talked about how to publish packages as scoped packages to work around using an already-taken package name. Scoped packages allow you to create a namespace for your package to avoid naming conflicts.

Scoped packages are private by default. However, you can choose to grant access to specific individuals who are allowed to use your package. Private packages require a paid subscription plan, but there is no need to worry about that. You can publish your scoped package as public to avoid any fees.

If you decide to make your scoped package public after publishing it, you can easily change its visibility by updating the access field in your package.json file from restricted to public.

Creating and publishing scope packages is a simple process. To do so, follow the steps below:

Project structure

Create a new project

Scoped-package  
└─ main.js

Project initialization

To begin, you need to initialize your directory by running the following command:

  npm init --scope=@username

When entering the package name in the npm prompt, follow this format: @username/package-name. See the example image below.

Writing your code:

Copy the generatePassword function from the previous section and paste it into the main.js file

Testing the package:

Follow the same procedure as described in the previous section to test your package.

Publishing:

To publish your scope package, open your terminal and run the command given below:

    npm publish --access public

Remember: By default, scoped packages are private. Another way to make a package public is by setting the access flag to public.

Ta-da! You have successfully published your first scope package. Visit the NPM registry to view it.

Installing the NPM package

After publishing a package to the NPM registry, it is best practice to install and use it to ensure it works as a regular package.

Project structure

Create a new project and initialize it using npm init.

Package     
└─ main.js

Installation

Use the following command to install the newly published package.

npm install packagname

You can use i instead of install in the npm command. For example, instead of typing npm install, you can type npm i

Usage

Open your main.js file and require the newly installed package.

const passwordGen = require("backendbro-password-generator")

const password = passwordGen(10, true, true, true) 
console.log(password)

Run your app

Simply run your application using:

node main.js

Conclusion

Knowing how to create NPM packages is a vital skill for Node.js developers. It enables them to contribute to the open-source community and simplify their workflows by avoiding the need to reinvent the wheel.

In this guide, you have learned what NPM and NPM packages are and their importance to software development. You have also learned how to create and publish packages on the NPM registry.

You too can become a part of the ever-evolving Node.js landscape by sharing your package. Join in on this journey, share your solutions, and let's shape the future of software development together, one package at a time.

Thank you for staying with me and have a great time coding! 😊

Useful Resources

NPM Official Documentation

What is Node.js and why should you use it in 2024

Ukagha Nzubechukwu — Thu, 18 Jan 2024 05:28:51 +0000

In the rapidly changing world of web development, Node.js emerged and solidified itself as an integral part of the modern-day web. Node.js has gained immense popularity in recent years as a powerful tool for developing scalable and high-performance applications. However, you may be wondering — what is the hype about Node.js and why should you consider using it in 2024? This article will delve deeper into Node.js, exploring its features, benefits, and use cases.

What is Node.js?

Node.js is a cross-platform runtime environment that runs JavaScript code outside a web browser. Node.js uses the powerful V8 JavaScript engine from Google Chrome for swift execution of JavaScript code.

Ryan Dahl introduced Node.js in 2009, and since then, it has gained widespread adoption in the web development ecosystem. At its initial release, Node.js was only supported on Linux and Mac OS X. It wasn't until July 2011 that the first Node.js build supporting Windows was released.

Dahl criticized the sequential programming approach, which could not effectively manage a significant number of simultaneous connections. This frequently resulted in a delay that blocked the execution of a program, thereby reducing the overall performance of the application.

With Node.js, developers can use JavaScript for server-side scripting. Notable organizations including Netflix, LinkedIn, Uber, and Twitter implement Node.js. In the latest StackOverflow survey, Node.js was ranked as the most popular Web Framework and Technology with a 47.12% adoption rate. With over 6.3 million websites using Node.js, it remains a top choice for building scalable and high-performance applications.

The problems Node.js aims to solve.

Ryan Dahl created Node.js based on a simple principle — operations must never block.

Node.js aims to solve various problems that developers have always struggled with. Some of these problems include:

Processing a large volume of requests simultaneously
Preventing I/O bottlenecks
Implementing concurrency safely and more predictably.

To address these challenges, Node.js implements the following:

Node.js applications run on a single thread, which helps it achieve its non-blocking and event-driven goal. This means an application can process many requests simultaneously without blocking the main thread.
Program flow in Node.js is directed through asynchronous callbacks, which eliminates any bottlenecks caused by waiting for an operation to finish.
Concurrency is implemented in Node.js by use of events. Events are emitted to notify the completion of an operation. With Node.js developers can implement concurrency and parallelism safely and predictably in their applications without worrying about race conditions or other issues.

Understanding Nodejs Architecture

Node.js has a unique architecture that sets it apart from traditional server-side technologies. Its non-blocking and event-driven design allows it to handle multiple requests simultaneously without blocking other operations. This makes Node.js highly scalable and particularly suited for high-traffic and real-time data processing applications.

The Node.js architecture is made possible by its single-threaded event loop, which listens for events such as incoming requests and calls the corresponding callback functions.
The event loop allows Node.js to avoid waiting for an operation to complete before moving on to the next one. When the skipped operation eventually completes, an event is emitted to notify the event loop to call its callback function. This feature allows Node.js to maintain a high level of performance when handling a large number of connections at once.

Node.js uses a support library called Libuv, which provides the event loop and manages asynchronous I/O operations. The Libuv handles most of the operating system tasks, such as file system operations, networking, and threading. The Libuv is crucial to Node.js's ability to handle concurrent tasks effectively.

Another core component of the Node.js architecture is the V8 JavaScript engine. The V8 is a high-performance runtime engine that executes JavaScript code at lightning-fast speeds.
The V8 engine uses the Just-In-Time (JIT) compilation technique to translate JavaScript code into machine code at runtime, which allows for faster and more efficient execution.

The V8 engine performs various optimizations, such as:

Inlining functions
Eliminating dead code
Optimizing memory usage — which helps to prevent memory leaks.

These optimizations ensure that the JavaScript code runs as efficiently as possible.

Node.js owes much of its speed and efficiency to the V8 Google Chrome engine. The V8, when combined with the Libuv, makes Node.js a top choice for building high-performance web applications.

Features of Node.js

Node.js is known for its non-blocking and event-driven mechanisms, but it also offers various other features that make it stand out. They are:

Operating System Operations: Node.js adds a vast range of new features to JavaScript, allowing developers to perform several operating system related tasks such as file system operations, running external commands, and gathering information about the system environment. These functionalities aid developers in communicating with the underlying operating system that is not available to browser-based JavaScript. Node.js provides some core modules to make these interactions possible.
Modules: In Node.js, modules are essential for organizing code into reusable and maintainable units. They are independent units of code that are self-contained and can be shared, imported, and reused in different parts of an application. This allows complex applications to be built out of smaller, simpler components. Node.js follows the CommonJS module system, which provides a simple and efficient way to create, import, and reuse code across different files. To make functions and variables accessible to other files, Node.js provides the module.exports interface.
NPM: Node.js comes with a powerful package manager called Node Package Manager (NPM), it simplifies the installation, sharing, and version control of Node.js modules, making it easier to share and reuse code in projects. NPM has become one of the largest open-source JavaScript module repositories.
To keep track of project-related metadata, NPM maintains a package.json file in your project. This file lists all the dependencies and their respective versions. Additionally, NPM allows developers to define and run scripts in their package.json file. These scripts can be used for several tasks like testing, building, or running the application. The most common scripts include start, test, and build.
Seamless frontend integration: Node.js is a popular choice for full-stack projects because it allows developers to use JavaScript for both frontend and backend.
Developers can use popular frontend frameworks like React and Angular to create dynamic and real-time interactions while serving static assets and rendering dynamic content on the server side. This combination simplifies development, fosters code consistency and reduces the need to switch between languages.
Large Community and Ecosystem: Node.js has gained immense popularity due to its thriving community of developers who contribute to its growth and improvement. This community makes it easy for developers to find solutions to common problems and share best practices.
This collaborative approach ensures that Node.js stays up-to-date with the latest trends and technologies.

Use Cases of Node.js

Node.js has a wide range of applications, including:

Web applications: Node.js is often used for building scalable and high-performance web applications. Its non-blocking and event-driven design makes it well-suited for I/O intensive applications. Node.js has popular frameworks like Express to provide a boilerplate for building robust web applications.
REST APIs: Node.js is a popular choice for developing RESTful APIs because of its lightweight and event-driven architecture. This architecture enables it to scale effortlessly and handle a large volume of requests. RESTful APIs often employ JSON (JavaScript Object Notation) for exchanging data. As JSON is native to JavaScript, working with JSON in Node.js is straightforward and seamless.
Real-time applications: Node.js is well-suited for building applications that require two-way communication and real-time updates.
Node.js provides libraries such as Socket.io to simplify the integration of real-time features in web applications such as chat platforms, collaborative tools, multiplayer games, and streaming services.
Microservices: Node.js is widely used in microservices applications, where services are divided into smaller, independent units, making it easier to scale, maintain, and deploy complex applications. Node.js's non-blocking model allows these services to handle a high volume of simultaneous requests without interfering with the execution of other tasks. Additionally, the lightweight and scalable nature of Node.js makes it a perfect fit for microservices that need to scale horizontally to handle increased traffic.
Single-Page Applications: Node.js is also used for developing single-page applications because it can render content on the server side. Node.js uses template engines like EJS and Handlebars to render HTML content and send it to the client, resulting in faster page loading times. This approach improves search engine optimization (SEO) and accessibility for users with slow or unreliable internet connections.

Challenges and Solutions

Node.js has many advantages due to its architecture, however, there are certain challenges associated with this approach.
Here are a few challenges that affect the single-threaded nature of Node.js and how to mitigate them.

CPU-Intensive Tasks:
1. Challenges: Since Node.js is single-threaded, it can only perform one task at a time. This can pose a problem when dealing with expensive CPU operations that can block Node.js' event loop, causing performance issues.
2. Solution: To mitigate this issue, it is recommended to distribute CPU-intensive tasks among different processes or threads using techniques such as asynchronous programming, clustering, and worker threads. This can significantly improve the application's performance by ensuring that one operation does not block the other.
Limited Multithreading:
1. Challenges: Due to the lack of native support, implementing multi-threading in Node.js can be challenging.
2. Solution: Node.js provides the worker_threads module for thread management. In addition to the worker_threads module, several NPM dependencies have been created to simplify the process of multi-threading in Node.js.
Callback Hell:
1. Challenges: Node.js heavily relies on callbacks to achieve its non-blocking, event-driven model. However, this approach often leads to a callback hell. This is when deeply nested callbacks can become difficult to read, maintain, and debug.
2. Solution: Developers can mitigate the callback hell by using async/await, Promises, and event emitters, which allows for clearer and more readable code.
Garbage Collection:
1. Challenges: Node.js optimizes memory management through garbage collection, which allocates and deallocates memory spaces. However, this can block other operations and reduce application performance.
2. Solution: Proper configuration of garbage collection can prevent performance issues and ensure smooth program execution. Developers should also consider application memory needs and avoid unnecessary memory-intensive operations.

Conclusion

Node.js continues to be a quintessential and versatile technology. Its non-blocking, event-driven architecture, built on the V8 JavaScript engine, has proven to be instrumental in developing scalable and high-performance applications.

Node.js's active and thriving community ensures that there will always be a solution to any problem. Developers can benefit from its rich ecosystem of libraries and tools for development.

Whether you are a beginner or an experienced developer, the broad range of features offered by Node.js makes it a compelling choice for software development in 2024.

Building a REST API using NodeJS, ExpressJS, and CockroachDB

Ukagha Nzubechukwu — Fri, 15 Sep 2023 11:56:14 +0000

In today's technology-driven world, there is a high demand for scalable and high-performance web applications. As a result, developers are constantly exploring new technologies and frameworks to simplify building robust and user-friendly applications.

With Node.js, Express, and CockroachDB, developers have a powerful combination for backend development, offering a seamless and adaptable environment for creating high-performing REST APIs.

In this tutorial, we will build a robust REST API to store and manage a book's essential details, such as the title, author, ISBN, and page count.

Prerequisites

This article assumes that you have a basic knowledge of the following:

TL;DR: The code for this tutorial is on GitHub.

Project Setup

First, create the following files and folders:

book-api
 ┣ controller
 ┃ ┗ Book.js
 ┣ database
 ┃ ┗ DB.js
 ┣ routes
 ┃ ┗ Book.js
 ┣ schema
 ┃ ┗ BookSchema.js
 ┣ config.env
 ┗ server.js

Below is a visual illustration of the files and folders needed for this project.

To continue, run the following command in the terminal to initialize the working directory.

npm init

Fill in the necessary information when prompted by this command, as shown below, then press ENTER.

Once completed, a package.json file will be generated. This file contains vital information and scripts that run and tests the application.
Update the package.json file with the following script:


"scripts": {
    "start": "nodemon server.js"
}

Visual illustration below:

Installing Dependencies

Run the following command to install the necessary dependencies.

npm install  express sequelize sequelize-cockroachdb dotenv

Quick note:

Express: Express is a NodeJS framework used to create web applications and REST APIs.
Sequelize: Sequelize is an ORM widely used by NodeJS developers to manage relational databases. This eliminates the need for writing raw SQL.
Sequelize-cockroachdb: This ORM is specific to CockroachDB.
Dotenv: Dotenv loads data from the config.env file into the NodeJS environment. By so doing, one can access those data using process.env. Dotenv makes an application more maintainable and more secure.

Lastly, install the nodemon dependency.

npm install nodemon -g

Nodemon: Nodemon automatically restarts a server whenever one saves a file. I omitted Nodemon in the first command because of the -g flag. The flag instructs NodeJS to install Nodemon as a global dependency. By so doing, one does not have to install nodemon ever again.

If you only need to use Nodemon once, you can omit the -g flag.

Creating a CockroachDB Cluster.

What is CockroachDB?
CockroachDB is a distributed SQL database management system. CockroachDB is designed to handle transactional workloads with low latency and high throughput. CockroachDB's high availability and fault tolerance ensures it can operate even if a node, zone, or region fails.

CockroachDB offers the scalability of NoSQL databases and the relational model of SQL databases, making it ideal for web applications that require flexibility and reliability. Its high compatibility makes it easy to port PostgreSQL applications to CockroachDB with minimal code changes.

Additionally, CockroachDB offers a high level of data consistency. CockroachDB is used by companies like — Comcast, Digital Ocean, and Bose.

Moving on, Follow these simple steps to set up a CockroachDB cluster.

Create a CockroachDB account or sign in if you already have one.
After signing in, click Create Cluster.
Select a preferred plan and click Create Cluster.
The CockroachDB cluster is currently being processed. Wait patiently while it completes.
Create an SQL user and password. These credentials will be necessary to connect to the newly created cluster from the application.
Safely store the credentials and click Next.
Voila! We have successfully created a CockroachDB cluster.

Retrieving the CockroachDB Connection String.

This section will demonstrate the steps to retrieve the connection string.

Log in to your CockroachDB account.
Click the Connect button in the top right corner.
Scroll down and copy the connection string.

Building the app components

Open the config.env file and set the following environment variables.

PORT = 8000
connectionString = postgresql://backendbro:<ENTER-SQL-USER-PASSWORD>@stone-muskox-9285.8nj.cockroachlabs.cloud:26257/backendbro?sslmode=verify-full

Make sure to paste your connection string.

Copy and paste the code below into the server.js file:

const express = require('express')
const dotenv = require('dotenv')

dotenv.config({path:"./config.env"})
const app = express()

app.use(express.json())
app.use(express.urlencoded({extended:false}))

const PORT = process.env.PORT 
const server = app.listen(PORT, () => {
    console.log(`Server started on 127.0.0.1:${PORT}`)
})

process.on("unhandledRejection", (err) => {
    console.log(err.message)
    server.close(() => process.exit())
})

In the code snippet above:

We imported some of the dependencies installed earlier.
We loaded the environment variables stored in config.env into process.env.
Next, we instantiated the Express app.
The following two lines of code are Express middlewares that enable us to retrieve the body of an HTTP request.
Afterward, we set our server to listen for connections on 127.0.0.1 and the designated port number.
Finally, we requested Node to shut down the server if a promise rejection is not handled.

To ensure everything is set up correctly, use the following command to run the application.

npm run start

Create a CockroachDB Connection
Next, open the DB.js file to establish a connection with the CockroachDB cluster.

const Sequelize = require('sequelize-cockroachdb')
const dotenv = require('dotenv')

dotenv.config({path:"./config.env"})
const sequelize = new Sequelize(process.env.connectionString, {logging:false})

module.exports = sequelize

In the code snippet above:

We imported the required dependencies and loaded the environment variables into the process.env
Next, we established a connection to our database.
Finally, we exported the database connection.

Creating the Book Inventory Schema.
Navigate to the BookSchema.js file and make the necessary updates with the code provided below:

const Sequelize = require('sequelize-cockroachdb')
const sequelize = require('../database/DB.js')

    const BookInventory = sequelize.define("BookInventory", {
        id:{
            type:Sequelize.DataTypes.INTEGER,
            autoIncrement:true,
            primaryKey:true
        },
        name:{
            type:Sequelize.DataTypes.TEXT,
            allowNull: false,
            unique: true
        },
        author:{
            type:Sequelize.DataTypes.TEXT,
            allowNull: false,
        },
        isbn:{
            type:Sequelize.DataTypes.INTEGER,
            allowNull: false,
            unique: true
        },
        pageCount:{
            type:Sequelize.DataTypes.INTEGER,
            allowNull:false
        }
   })

module.exports = BookInventory;

In the code snippet above:

We used the define method to create a Schema, which enables us to store the specified information of a book.
Lastly, we exported the newly created Schema for later use.

Sequelize automatically manages timestamps.

Creating the Controllers.
In this subsection, we'll write code to handle the requests and responses of the application. Navigate to the controller folder and update the Book.js file with the code below:

To begin, import the Schema we created in the previous subsection.

const BookInventory = require('../schema/BookSchema.js')

CREATE BOOK:

    const createBook = async (req,res) => {    
        let book = await BookInventory.sync({force: false})
        book = await BookInventory.create(req.body)
                    .catch(err => res.status(500).json({message: err.message}))

        res.status(201).json({data: book})
    }

In the code snippet above:

The BookInventory.sync method creates a new table based on the model's schema. By setting force:false, sequelize avoids deleting the table and only update it.
The BookInventory.create method allows us to insert our book data into the database.
Finally, we return the response.

TO GET ALL BOOKS

    const getAllBooks = async (req,res) => {
        const books = await BookInventory.findAll()
                     .catch(err => res.status(500).json({message: err.message}))

        res.status(200).json({length:books.length, data:books})
     }

In the code snippet above:

We retrieve and return all the books that are stored in the database.

TO GET SINGLE BOOK

 const getSingleBook = async (req,res) => {
        const {id} = req.params 

        const book = await BookInventory.findOne({ where: {id} })
                    .catch(err => res.status(500).json({response: err.message})) 

        res.status(200).json({data:book})
    }

In the code snippet above:

We destructured the id passed into the request parameter.
We queried the database for any entry that match the specified ID and returned the response.

TO UPDATE A BOOK

    const updateBook = async (req,res) => {
        const {id} = req.params
        let book = await BookInventory.findOne({ where: {id} })
        .catch(err => res.status(500).json({message: err.message}))     

        if(!book) {
            return res.status(404).json({message:`No book found with ID: ${id}`})
        }

        book = await book.update(req.body)
        res.status(200).json({data:book})
    }

In the code snippet above:

We updated the details of a book that matches the specified ID.

TO DELETE A SINGLE BOOK

    const deleteSingleBook = async (req,res) => {
        const {id} = req.params 
        await BookInventory.destroy({ where: {id}})
                    .catch(err => res.status(500).json({message: err.message}))

        res.status(202).json({data:"Book deleted"})
    }

In the code snippet above:

We deleted the book that matches the specified ID.

TO DELETE ALL BOOKS

    const deleteAllBooks = async (req,res) => {
        await BookInventory.destroy({ where: {} })
                .catch(err => res.status(500).json({message: err.message}))

        res.status(202).json({data:"Books deleted"})
    }

In the code snippet above:

We deleted all books stored in the database.

Finally, export the controllers.

    module.exports = {
        createBook, 
        getAllBooks,
        getSingleBook,
        updateBook,
        deleteSingleBook,
        deleteAllBooks
    }

Creating the Routes
Let’s create the endpoints to send requests and receive a response. Navigate to the routes folder and open the Book.js file. Update the file with the following code:

    const router = require('express').Router()
    const {
        createBook, 
        getAllBooks,
        getSingleBook,
        updateBook,
        deleteSingleBook,
        deleteAllBooks
    } = require('../controller/Book.js')

    router.post('/create', createBook)
    router.get('/getAllBooks', getAllBooks)
    router.get("/getSingleBook/:id", getSingleBook)
    router.put('/updateBook/:id', updateBook)
    router.delete('/deleteSingleBook/:id', deleteSingleBook)
    router.delete('/deleteAllBooks', deleteAllBooks)

    module.exports = router

In the code snippet above:

We created a new router object to handle requests.
Next, we imported the controllers and associated them with a specified method and URL.
Lastly, we exported the router object.

Rounding up
Return to the server.js file and import the router object.

const express = require('express')
 const dotenv = require('dotenv')

    dotenv.config({path:"./config.env"})
    const app = express()

    app.use(express.json())
    app.use(express.urlencoded({extended:false}))

    // router object
    const bookRoute = require('./routes/Book.js')
    app.use('/api/v1', bookRoute)

    const PORT = process.env.PORT 
    const server = app.listen(PORT, () => {
        console.log(`Server started on 127.0.0.1:${PORT}`)
    })

    process.on("unhandledRejection", (err) => {
        console.log(err.message)
        server.close(() => process.exit())
    })

Conclusion

In conclusion, building a REST API with Node.js, Express, and CockroachDB provides developers with an effective solution for developing robust and scalable web applications.

Resources

What is a Cache?

Ukagha Nzubechukwu — Sat, 15 Jul 2023 05:48:13 +0000

A cache pronounced "cash" is a temporary high-speed storage layer that stores data in a location that is quicker to access. They allow a user to reuse previously computed data. Caches are essential for high-performance computers and applications because they provide faster access to frequently computed data.

If frequently accessed data is stored in a cache, the average data memory access time can be reduced, thus reducing the total execution time of an application. A cache can be found in computers, web browsers, etc. Here are some of the most common ones:

CPU (Central Processing Unit) cache
Disk cache
Web cache
Application cache

Memory access time refers to the time it takes to retrieve data from memory.

Caching in hardware and software

Caching is a process of storing frequently accessed data in temporary storage (cache) to speed up future requests for that data.

Most computers now have another level of memory referred to as the cache. The CPU cache is a compact memory layer that is positioned logically between the CPU register and the main memory, which stores computer instructions that are frequently accessed. A cache's storage capacity is less than the main memory but has a high data retrieval performance.

When the CPU needs to access data, it first checks the cache. If the data is found in the cache, it can be accessed much more quickly than if it had to be retrieved from the main memory. This results in faster processing times; which is important in high-performance computing environments where speed is crucial.

Additionally, caches can improve the overall system performance by reducing how often the CPU has to access main memory, which is slower and more resource-intensive.

Your favorite online browser has a cache. A browser will always give you the choice to remove cached files and images whenever you attempt to clear your browsing history.

The browser's cache improves your web experience by enhancing the performance of frequently visited websites.

How do caches work?

When a CPU attempts to fetch data in the cache, and it is available, this is called a cache hit. The percent of trials that result in a cache hit or miss is termed the cache hit ratio or rate.

A cache's data is typically stored in a fast-access memory.

A cache miss will occur when the data fetched is not present. When this happens, the data is taken from the main memory and copied into the cache. Copying new data into a Cache depends on the caching algorithm, cache protocol, and system policies implemented.

Caching algorithms

Caching algorithms are implemented by giving each item in the cache a strength rating and removing the ones with the lowest ratings when new data is stored. The following are some examples of caching algorithms:

Least recently used: When there is not enough room in the cache, It removes an item that was least used recently.
Least frequently used: This algorithm removes the items with the lowest usage rates.
Most recently used: This evicts recently used items first.
First in, first out (FIFO): In a FIFO caching algorithm, any item added first to the cache will be the first one removed when there is no space left.
Last in, first out (LIFO): This caching algorithm will remove any item added last.

Cache policies

Cache read policies: This policy illustrates how a cache responds to data requests. A read request may succeed or fail in fetching data from a cache.
Should we get a cache miss, the main memory has to serve the request. We would want to reduce the chances of this happening, especially if it is a read-intensive application.
Cache write policies: This policy depicts how data changes in the cache. They are:

Write-through cache: This policy stores data directly into the cache and database. It ensures that data is consistent. The cache can serve as a backup since the data will always be consistent with the one in the database.
This policy is appropriate for applications that do not have high write requests. A high write volume will slow down the application's performance because it stores data in two locations.

Write-back cache: In this policy, data is written only to the cache. The data is copied and stored in the underlying database. This policy promotes low latency.
The write-back cache policy is utilized in write-intensive applications since writing data to the cache is quicker than writing to the main memory.

Write-around cache: It directly stores data in the database. When the write operation concludes, the cache is then updated. When there are a lot of write I/O operations, the write-around policy protects the cache from being flooded.
Data is not cached in this method unless it is read from the storage, which is a drawback. This policy is not suited for read-heavy applications.

How to implement a cache network.

Keeping the most frequently used data in the fast cache memory is the basic idea of a cache network. The average memory access time to retrieve data will thus be reduced.

When implementing a cache layer, one should consider the validity of the data and its importance on the scale of preference. A well-implemented cache network will lead to a high cache hit rate.

Filters such as TTL (time to live) should be used to expire out the data present in the cache as at when due.

Another consideration may be whether or not the cache network requires a much higher availability. In-memory engines such as Redis and NGINX provide high availability.

A well-implemented cache network can function as an independent storage layer.

Types of cache.

There are four types of cache:

CPU cache: This cache is located on the processor chip and stores frequently accessed data and instructions. CPU Cache makes up three groups:
- L1 cache memory - It tends to be small. It holds only a limited amount of data.
- L2 cache memory - The secondary cache is an intermediary between your device's processor and the main memory. When a cache miss occurs, the CPU immediately checks the L2 for the missing data.
- L3 cache memory - The L3 is the slowest among CPU cache units. It is a specialized memory designed to boost L1 and L2 performance.
Web cache: Web caches keep track of information from servers, browsers, and websites so they can be easily retrieved when fetched to shorten loading times. There are four types of web cache:
- Site cache: The first time you visit a website, the site cache stores information about your activity. When you access the web page offline, it retrieves the previously saved data from the site cache.
- Browser cache: It also acts like the site cache. It stores the details of the frequently visited websites to serve them up faster whenever requested.
- Micro cache: It stores the static components of a dynamic website.
- Server cache: It helps reduce server load.
Application/Software cache: This cache is used by software applications to store frequently accessed data, such as configuration files, templates, and other resources. It helps improve data retrieval performance.
Distributed cache: Big corporations store data across multiple database servers using a distributed cache.
Disk cache: This cache is used by operating systems to speed up disk operations. It stores frequently accessed data in memory so it can be read or written to disk more quickly.

Importance of a cache.

Offline data access: Internet browsers use cache to store data temporarily. By caching regularly accessed data, browsers can serve previously visited web pages from their disk instead of from the internet.
Reduced database cost: Highly available cache such as Redis and Nginx can serve as a standalone storage layer. A cache helps to reduce the number of databases needed, thus reducing the cost of operation.
Data integrity and consistency: Data can remain in a static database where they are durable and thorough. Caches help to maintain data integrity and consistency by taking a copy or snapshot of what is in the database — ensuring that data is consistent across all users.
Increase application efficiency: Redirecting a chunk of the read requests to a cache helps reduce the load on an application and improves the application's performance.

Drawbacks of a cache.

Data validity: The main drawback of a cache is the possibility of displaying outdated data to a user due to improper cache maintenance, which can lead to evictions and low cache hit rates.
Bottleneck: Caches can cause a bottleneck if they are not properly managed. When a cache is too small, it can quickly become overwhelmed; this might lead to cache misses and slower processing times. In some cases, caches can also cause contention for shared resources, thus slowing down processing times.
High cost: Caches are built using high-speed memory chips, which are more expensive. Additionally, caches require complex hardware and software design to ensure that they are effective in improving performance.
Volatile: The cache memory is volatile since it stores data temporarily. Caches are not meant to store data permanently, but rather to provide quick access to data needed frequently. As a result, caches are volatile and require constant refreshing to keep the data up-to-date and accurate.

Conclusion

So far, we have learned what cache and caching are, how to implement a cache network, its types, and its merits and demerits. Without a cache, we would have to start afresh anytime we close a website or a computer.
I know this article is a long read. I am happy you made it to the end. 😊

Resources

A step-by-step guide: How to use MongoDB with Node.js.

Ukagha Nzubechukwu — Fri, 26 Aug 2022 20:08:47 +0000

Introduction

When working with a server, one will always have to save and retrieve data using a database. There are many server-side languages and databases available. In this article, you will learn how to use MongoDB with Node.js.

MongoDB is a non-relational database. It is a document-oriented storage system. It stores and retrieves data in JSON format, instead of the traditional table and row format used in relational databases ( MYSQL, PostgreSQL ).

Prerequisites

A supported version of Node.js installed
A MongoDB Atlas account
Basic knowledge of Node.js and Express.js

Getting started

To demonstrate how to use MongoDB with Node.js, we will build a simple book inventory. You will learn how to add, get, edit, and remove books from your inventory.

Make sure that your code editor has the following folders and files ready.

Installing dependencies

Quick note:

Mongoose is a library that creates a connection between MongoDB and an Express-based application.

Dotenv is used to load data from a .env file into a Node.js environment so it can access it using process.env.

Moving on, run the commands below in your terminal to install the dependencies needed for this project.

npm install express 
npm install mongoose
npm install  dotenv

Retrieving the MongoDB connection string

Follow these easy steps to retrieve the connection string:

Click on connect on your Database Deployment dashboard.

Choose the Connect to your application option.

Copy the connection string

Writing code

At this point, the dependencies and connection string should be ready for use.

The server.js file should look like this for the time being

const express = require('express')
const dotenv = require('dotenv')
const path = require('path')
const app = express()

dotenv.config({path: './config/config.env'})
app.use(express.json())

const port = process.env.port
app.listen(port, () => {
    console.log(`port ${port} connected...`)
})

The config.env file will hold the following environment variables:

port = 8080
mongo_uri = mongodb+srv://mongodb-template:<password>@cluster0.8lmmv.mongodb.net/myFirstDatabase?retryWrites=true&w=majority

Restart your server after copying the code snippet above into your config.env file

Replace <password> with the actual password of the database

Next step, let's create a MongoDB connection, in the db.js file.

const mongoose = require('mongoose')

const connectDb = async () => {
const conn = await mongoose.connect(process.env.mongo_uri,  {
useNewUrlParser: true,
useUnifiedTopology: true
})
console.log(`mongodb connected: ${conn.connection.host}`)
}

module.exports = connectDb

Now that the database connection is ready, update the server.js file.

const express = require('express')
const dotenv = require('dotenv')
const connectDb = require('./database/db')
const app = express()

dotenv.config({path:'./config/config.env'})
app.use(express.json())

//database connection
connectDb()

const port = process.env.port
app.listen(port, () => {
    console.log(`port ${port} connected...`)
})

Creating the schema

MongoDB schema is a JSON object that decides what the database is allowed to be stored.

Setting up BookSchema.js :

const mongoose = require('mongoose')

const BookSchema = new mongoose.Schema({
    title:{
        type:String,
        required:true,
        unique:true
    },
    author:{
        type:String,
        required:true,
        unique:true
    },
    isbn:{
        type:String,
        unique:true
    }
})

module.exports = mongoose.model('BookSchema', BookSchema)

Routes

Starting on the book.js file, bring in the router and BookSchema model.

const router = require('express').Router()
const Book = require('../model/BookSchema')

The book.js file will contain the following requests:

POST request

router.post('/', async (req,res) => {
    const { title, author, isbn } = req.body
    const newBook = await Book.create({ title, author, isbn })
    res.status(201).json({ 
        success:true, 
        data:newBook 
    })
})

The code snippet above will store the name, author, and isbn of a book.

GET request

There will be two variants of the GET request. One will GET all books while the other will GET just a particular book.

router.get('/',  async (req,res) => {
    const books = await Book.find()
    res.status(200).json({ 
        success:true, 
        data: books, 
        num: books.length
    })
})

router.get('/:id',  async (req,res) => {
  const book = await Book.findById(req.params.id)  
  res.status(200).json({ 
      success:true, 
      data: book 
    })
})

PUT request

router.put('/:id', async (req,res) => {
    let book = await Book.findById(req.params.id)
    book = await Book.findByIdAndUpdate(req.params.id, {$set:req.body}, {
        new:true,
        runValidator:false
    })  
    res.status(200).json({ 
        success:true, 
        data: book 
    })
})

The code snippet above updates the book details that match the specified ID.

DELETE request

This operation will also have two variants in case we want to DELETE one or all entries from the database.

router.delete('/:id', async (req,res) => {
    await Book.findByIdAndRemove(req.params.id)
    res.status(200).json({ 
        success:true, 
        data: 'book deleted' 
    })
})

router.delete('/', async (req,res) => {
    await Book.deleteMany()
   res.status(200).json({ 
       success:true, 
       data: 'All books deleted' 
    })
})

Lastly, export the router.

module.exports = router

Take a deep breath. At this point, we are almost done.

Update the server.js file one last time with the router.

const express = require('express')
const dotenv = require('dotenv')
const connectDb = require('./database/db')
const app = express()

dotenv.config({path:'./config/config.env'})
app.use(express.json())

//database connection
connectDb()

//mount the route
const bookRoute = require('./routes/book')
app.use('/api/v1/book', bookRoute)

const port = process.env.port
app.listen(port, () => {
    console.log(`port ${port} connected...`)
})

Conclusion

In this article, you learned how to use MongoDB with Node.js by creating a simple project. I hope you found this tutorial easy to follow.

Happy coding! 😀

Credits

How to Push to Github from VScode - For Windows

Ukagha Nzubechukwu — Thu, 05 May 2022 20:51:00 +0000

Introduction

GitHub is a cloud hosting platform for software development and version control. GitHub facilitates collaborative programming by making repositories accessible online.

To begin, it's important to distinguish between Git and Github.
Git is a powerful version control system that allows developers to track and save changes in their codebase locally. Git allows for offline work and provides a backup in case of server failure.
With Git, developers can push their changes to a remote repository, such as GitHub, enabling them to collaborate and work together seamlessly.
Git provides features like commit history, diffing, and reverting changes, which make it easy to manage and maintain code over time.

On the other hand, GitHub is an cloud-based Git repository that allows users to store, manage, track, and collaborate on software projects.
GitHub makes it easier for individuals and teams to use Git for version control. GitHub offers a range of features and tools to support software development.

This article will guide you on how to set up your coding environment to push your code from VScode to GitHub. You will use the GitHub SSH keys to establish a connection, making the process more secure. This article provides a comprehensive guide that is easy to follow.

Goals

Setting up the SSH keys
Pushing to Github

Prerequisites

Getting started

Open Git bash and configure the credentials to match your Github account details.

Run the following commands one after the other:

git config  --global  user.name  "username" 
git config  --global  user.email  "your_email@email.com"

To confirm that you have entered the correct details, run this command:

git config -l

Getting the SSH Keys

SSH stands for Secure Shell. The SSH protocol allows you to connect and authenticate to remote servers and services securely. By using SSH keys, you can easily connect to your GitHub account without providing your credentials each time you visit. GitHub SSH enables you to securely access and write data to specific repositories.

Moving on, to obtain the SSH keys, you will need a Key Fingerprint first. Follow these simple steps to generate one:

Open Git bash
Run the command below:

 ssh-keygen -t ed25519 -C "your_email@email.com"

Press Enter when asked: "Enter a file in which to save the key". It will store the key in the default location. Although you can specify a file if you wish to.
When prompted to enter a passphrase, type in your chosen passphrase and then press Enter.

Don't worry if your inputs are not visible. It's a security feature to prevent shoulder surfing. Carefully enter a passphrase and store it safely for future use.

To proceed, re-enter your passphrase and click the Enter button to complete the process.

At this point, you should have a Key fingerprint.

Generating the SSH Key

Run the following commands one after the other:

 eval "$(ssh-agent -s)"
 ssh-add ~/.ssh/id_ed25519

Enter the passphrase you created in the last sub-section.
Navigate to the location where the identity was added on your PC.

Drag and drop the id_ed25519.pub file into your VScode to reveal the SSH Key.

Adding the new SSH Key

Navigate to the Add new SSH Key page on your GitHub account and paste your new SSH key in the key field.

Pushing to Github

After successfully setting up SSH, follow these simple steps to push a mock project to Github.

Below is a visual illustration of the mock project.
It is bland html file and a js file that logs ('I just pushed to GitHub') to the console.

First, open your terminal and select bash as your default profile by clicking on the dropdown icon.

Return to your Github account, and navigate to the create repository section.
Enter a repository name of your choice
You can skip the description
Ignore the other checkboxes and click create repository

Return to your VScode terminal and enter the following commands:

git init

git add .

git commit -m [Enter your message of choice here]

git remote add origin https://github.com/backendbro/mock_project.git

Copy the line above from your repository dashboard, as yours will be different

git branch -M main

git push -u origin main

Select the "Sign in with your browser" option when prompted by the Git Credential Manager. Then, wait patiently for a browser window to open so you can complete the process.

Once the authentication and authorization process was completed, the mock project was pushed to GitHub.

Voila! We successfully pushed our project from VScode to GitHub.

Conclusion

You have successfully set up your SSH Keys, and pushed a mock project to GitHub from VScode. Now, pushing your projects to GitHub will be a breeze as you have been authenticated and authorized.
I hope that with this newfound knowledge, you can showcase your incredible project to the world.
Happy coding!

Forem: Ukagha Nzubechukwu

Why Most Business AI Fails — And How RAGS Gives Companies a Real Brain.

Why Most Business AI Breaks Before It Delivers Value

What Is RAGS and Why It Matters

Why RAGS Is a Foundation, Not a Feature

Conclusion

How to send Automated Personalized Cold Emails with n8n to Boost Response Rates

Prerequisites

Why Traditional Cold Email Doesn’t Work Anymore

How to Send Automated Personalized Cold Emails with n8n

Step 1 — Create an n8n account

Step 2 — Add your trigger

Step 3 — Connect your Google Sheet to the workflow

Step 4 — Personalize your emails with ChatGPT

Step 5 - Update Google Spreadsheet

Step 6 — Send your personalized emails automatically

Step 7 — Automate the workflow

Conclusion.

Step-by-Step Guide: Deploying a Full-Stack App on AWS EC2.

Introduction

Prerequisites

Step 1: Launch an EC2 instance.

Step 2. Connect to your AWS EC2 Ubuntu Instance

Step 3: Update and Upgrade your instance.

Step 4: Setting up a PostgreSQL Database.

Step 4: Set up your application

Server set up

Client set up

Step 5: Installing and Configuring Nginx

Step 6: Setting up environment variables

Step 7: Enable firewall

Step 8: Enable SSL

Conclusion.

How to fix the “aws-elasticbeanstalk-ec2-role” error in AWS Elastic Beanstalk.

Prerequisites

Understanding the "aws-elasticbeanstalk-ec2-role" error

How to fix the “aws-elasticbeanstalk-ec2-role” error

Conclusion

Boost your learning with Glasp: A Comprehensive Guide.

Prerequisite

An Introduction to Glasp

What is Glasp

Glasp highlighting and note-taking feature

Glasp community building

Glasp tag system

Glasp user profile

Glasp cross-platform compatibility

Installing Glasp.

Setting up Glasp

Glasp in action

Highlighting

Note-taking

Comment

Tag

Using Glasp in PDFs

Using Glasp as a YouTube companion

A view of the Glasp profile

Benefits of Glasp

Conclusion.

Credits and Further reading

How To Boost Your Node.js Performance by Implementing Caching With Redis.

Introduction

Prerequisites

An Introduction to Caching.

An Introduction to Redis

Setting up Redis.

Caching in Action

Project setup

Quick note:

Writing code

Testing

Benchmarking

Without Caching:

With caching:

Conclusion

Further Reading

Resources

A step-by-step guide: How to create and publish an NPM package.

Prerequisites

What is NPM?