DEV Community: Tharaka Sandaruwan

Demystifying Serverless Architecture: Why Your Next API Should Be Event-Driven

Tharaka Sandaruwan — Tue, 10 Feb 2026 18:42:43 +0000

In the modern cloud era, the term "Serverless" is often thrown around as a buzzword. However, for a backend engineer, it represents a paradigm shift from managing infrastructure to orchestrating logic. If you are still worried about CPU utilization and memory patching, it’s time to look at the event-driven world.

What is Serverless, really?

Serverless does not mean the absence of servers; it means abstraction of infrastructure. You provide the code (the "Function"), and the cloud provider handles the execution, scaling, and availability.

In the AWS ecosystem, this is primarily powered by AWS Lambda.

Let’s Take a Real-World Example: A Food Delivery App

Imagine you are building the backend for a food delivery service.

The Request (API Gateway): A user places an order. The request hits the API Gateway, which acts as the entry point, handling authentication and rate limiting.
The Logic (AWS Lambda): The Gateway triggers a Lambda function. This function validates the order and calculates the total. It only runs for the few milliseconds needed to process the order.
The Data (DynamoDB): The order details are stored in DynamoDB. Being NoSQL and serverless, it scales instantly to handle thousands of orders during lunch hour.
The Decoupling (EventBridge): Once the order is saved, we emit a OrderPlaced event to Amazon EventBridge. This allows other parts of the system (like the Driver Notification service or the Kitchen Dashboard) to react independently without slowing down the main order flow.

Serverless Framework vs. Terraform: The Right Tool for the Job

One common point of confusion is whether to use Serverless Framework or Terraform. Both are Infrastructure as Code (IaC) tools, but they serve different purposes.

Serverless Framework: Highly specialized for application developers. It streamlines the deployment of Lambda, API Gateway, and SQS/SNS with a developer-friendly syntax (serverless.yml).
Terraform (HashiCorp): A broader tool for DevOps professionals. It is designed to manage complex, multi-cloud infrastructure like VPCs, RDS instances, and Kubernetes clusters using HCL (HashiCorp Configuration Language).

The Verdict: If your primary focus is building and deploying serverless functions quickly, the Serverless Framework is the industry standard for a frictionless experience.

Why the Tech World is Moving to Serverless

Zero Idle Costs: You pay only for the execution time. If no one uses your API at 3 AM, your cost is exactly zero.
High Availability by Default: AWS Lambda and DynamoDB are distributed across multiple availability zones automatically.
Focus on Value: Engineers spend time on business logic (Domain) rather than server maintenance (Infrastructure).

Conclusion

Serverless is more than just a cost-saving measure; it’s a way to build decoupled, resilient, and highly scalable systems with minimal operational overhead. As we move towards 2026, the "function-first" mindset is becoming the default for high-growth startups and enterprises alike.

Understanding the Linux CLI to Master It

Tharaka Sandaruwan — Mon, 26 Feb 2024 16:22:16 +0000

The Linux command line interface (CLI) is a powerful tool that allows users to interact with the operating system and execute commands efficiently. To become proficient in using the Linux CLI, it's essential to understand how to read manuals for commands, pass options to commands, and get help when needed. In this article, we'll explore these aspects of mastering the Linux CLI.

Reading Manuals for Commands:

Linux provides manual pages (man pages) for most commands, offering detailed information on their usage, options, and examples. To access the manual for a command, use the "man" command followed by the name of the command.

Example:

This command displays the manual page for the "ls" command, providing information on its various options and usage scenarios. Use the arrow keys or Page Up/Page Down keys to navigate through the manual pages. Press "q" to exit the manual.

Passing Options to Commands:

Many Linux commands accept options or flags that modify their behavior. Options are usually preceded by a hyphen (-) or double hyphen (--). To pass options to a command, simply append them after the command name.

Example:

In this example, the "-l" option is passed to the "ls" command to display detailed information about files and directories.

Getting Help for Commands:

If you're unsure about how to use a command or need a quick refresher on its syntax, you can use the "--help" option or consult online resources.

Example:

This command displays a brief help message for the "ls" command, listing its available options and their descriptions. Alternatively, you can search for command usage and examples on Linux community forums, websites, or documentation.

Tips for Mastering the Linux CLI:

Practice regularly: The more you use the command line, the more comfortable you'll become with its nuances and capabilities.
Experiment with different commands: Try out various commands and options to familiarize yourself with their functionalities.
Take notes: Document useful commands and their options in a personal cheat sheet for quick reference.
Join online communities: Participate in Linux forums and communities to learn from others and seek assistance when needed.

By understanding how to read manuals, pass options, and get help for commands, you'll gain confidence and proficiency in mastering the Linux command line interface. With practice and persistence, you'll become adept at efficiently managing tasks and workflows in the Linux environment.

Mastering Standard Commits: Quick Guide to Structured Commit Messages

Tharaka Sandaruwan — Wed, 27 Dec 2023 18:34:34 +0000

Hey fellow devs! 👋 Today, let's dive into the world of "Standard Commits" and why they're the secret sauce to leveling up your version control game. Whether you're a seasoned pro or just getting started, writing standardized commit messages can make your collaboration smoother, your history cleaner, and your future self a lot happier. So, let's get down to the nitty-gritty and learn how to craft commits like a pro.

Why Standard Commits?

Before we jump into the how, let's quickly chat about the why. Standard Commits bring order and clarity to your project's version history. By adopting a common convention, you're giving your team and your future self a roadmap to understand the changes in your codebase. No more deciphering vague commit messages or wondering what that mysterious "fixed stuff" commit actually did.

The Basics

Alright, let's break down the basics of Standard Commits using the following conventions:

fix: A bug fix. Because, let's face it, bugs happen, but so does fixing them.
build: Changes that impact your build system, whether it's gulp, webpack, or another build tool.
per: Improvements in performance. Who doesn't love a faster app?
feat: The star of the show! A new feature that you've added to your project.
chore: A task that isn't a feature, bug fix, or build change. Think of it as housekeeping for your codebase.
docs: Changes in the documentation of your project. Because good documentation is key!
style: Anything related to the aesthetics of your app. Keep it looking sharp!
refactor: A spring cleaning for your code. Restructuring without changing the external behavior.
test: Changes related to testing. Testing is caring, right?
improvement: Making something better without introducing a new feature.

How to Write Standard Commits

Now, let's break down how to write these commits in a way that makes sense and is easy to follow. Consider this a mini cheat sheet:

Start with the type: Begin your commit message with one of the defined types (e.g., fix, feat, chore).

fix: resolve issue with login button not working

Be concise and clear: Keep it short and sweet. Clearly describe what your commit is doing.

feat: add dark mode toggle to settings

Add more details if needed: If your commit needs additional context, provide it in the body of the message.

feat: add dark mode toggle to settings

This commit introduces a user-friendly toggle switch in the settings menu, allowing users to switch between light and dark modes seamlessly.

Additional Resources

Ready to explore more? Check out these links for in-depth knowledge:

Putting It Into Practice

Now that you know the ropes, start incorporating Standard Commits into your workflow. Your future self and your teammates will thank you for the clear, structured history. Remember, communication is key in any relationship, and that includes your relationship with your codebase!

So, there you have it! Standard Commits in a nutshell. Give it a spin in your next project, and let the clean commit messages tell the story of your code. Happy coding, friends! 🚀

How to Deploy Your React or Vite Project on GitHub Pages using gh-pages

Tharaka Sandaruwan — Mon, 25 Dec 2023 22:04:05 +0000

GitHub Pages provides a simple and free way to host and showcase your web projects. If you’ve built your project using React or Vite, deploying it on GitHub Pages is a straightforward process. In this guide, we’ll walk through the steps of deploying your React or Vite project using the gh-pages library.

Prerequisites
Before you begin, ensure you have the following:

GitHub account.
A React or Vite project hosted on GitHub.

Step 1: Install gh-pages on your project

Go to your project folder and install the gh-pages package as a dev dependency in your project. Open your terminal and run the following command:

npm i gh-pages --save-dev

For yarn users:

yarn add gh-pages -D

Step 2: Update your package.json

Open your package.json file and update it as follows:

{
  "homepage": "http://<git username>.github.io/<repo name>", // Add this line
  "name": "example",
  // ...Other scripts
  "scripts": {
    // ...Other scripts
    "predeploy": "npm run build", // Add this line
    "deploy": "gh-pages -d <build folder name>"  // Add this line
  }
}

Let’s say your github username is ‘gituser’ and your project hosted repository name is 'repo'. In this case, your package.json is something like this.

This configuration sets up the necessary scripts to build your project before deploying it with gh-pages.

If you are using vite Update the vite.config.js as follows before the deployment:

Step 3: Deploy Your Project

Now that gh-pages is set up, deploy your project by running the following command:

npm run deploy

For yarn users:

yarn deploy

This command will deploy your build folder into the gh-pages branch in your github repository. You can verify it by navigating your github project repository action tab. It will appear like this. Once deployment is complete, you will see the green tick.

Step 4: Configure GitHub Pages

Go to your GitHub repository.
Click on the “Settings” tab.
Scroll down to the “GitHub Pages” section.
In the “Source” dropdown, select the gh-pages branch.
Click “Save.”

Your React / Vite project is now deployed on GitHub Pages! You can access it using the link provided in the “GitHub Pages” section of your repository settings.

Tips and Troubleshooting

Custom Domain:
If you have a custom domain, configure it in the “Custom domain” field in the GitHub Pages settings.
404 Issues:
If you encounter 404 issues, ensure that your router is configured properly. For React Router, set the basename property in your BrowserRouter.

Conclusion

Deploying your React/Vite project on GitHub Pages using gh-pages is a quick and effective way to showcase your work. By following these simple steps, you can easily share your web applications with the world. Happy coding!