DEV Community: Bassem Hussein

🕒 Automating Periodic Tasks with EventBridge Scheduler, .NET, and CloudFormation

Bassem Hussein — Mon, 27 Oct 2025 21:35:10 +0000

Many applications need to perform tasks on a recurring schedule — refreshing data, syncing APIs, or cleaning up records. Instead of managing EC2 cron jobs or containers, AWS gives you a fully managed option: Amazon EventBridge Scheduler.

In this post, we’ll build a simple proof of concept (POC) showing how to trigger a .NET Lambda function on a schedule using AWS CloudFormation.

We’ll also discuss what to do if your job takes longer than the Lambda time limit of 15 minutes.

🧩 What You’ll Build

You’ll deploy:

A .NET 8 Lambda function that simulates fetching stock prices
A CloudFormation template that defines:
- The Lambda function and its IAM role
- An EventBridge Scheduler that runs every 10 minutes
- An SQS Dead Letter Queue (DLQ) for failed invocations

Here’s the architecture:

⚙️ Step 1. Create a .NET Lambda Function

Start by creating a simple .NET 8 Lambda that logs a simulated stock price.

🧱 Project Setup

dotnet new lambda.empty-function -n StockPriceUpdater
cd StockPriceUpdater

🧠 Function Code (`Function.cs`)

using System.Text.Json;
using Amazon.Lambda.Core;

[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace StockPriceUpdater;

public class ScheduledJobInput
{
    public string JobType { get; set; } = string.Empty;
    public object? Payload { get; set; }
}

public class Payload
{
    public string AccountCode { get; set; } = string.Empty;
}

public class Function
{
    public async Task InvokeAsync(ScheduledJobInput input, ILambdaContext context)
    {
        context.Logger.LogLine($"[StockPriceUpdater] Triggered for JobType: {input.JobType}");

        if (input.Payload is JsonElement payloadJson)
        {
            var payload = payloadJson.Deserialize<Payload>();
            context.Logger.LogLine($"AccountCode: {payload?.AccountCode}");
        }

        await UpdateStockPricesAsync(input.JobType);
    }

    private Task UpdateStockPricesAsync(string jobType)
    {
        var price = Math.Round(new Random().NextDouble() * 100, 2);
        Console.WriteLine($"[{jobType}] Simulated stock price: ${price} at {DateTime.UtcNow:O}");
        return Task.CompletedTask;
    }
}

This function accepts a small JSON payload and logs a random “stock price.”

It’s a simple stand-in for any periodic background task you might need.

📜 Step 2. Deploy with CloudFormation

Save the following as stock-price-updater.yml:

AWSTemplateFormatVersion: '2010-09-09'
Description: Lambda triggered by EventBridge Scheduler for periodic stock updates

Parameters:
  ResourcePrefix:
    Type: String
    Default: stock-updater
  LambdaCodeBucket:
    Type: String
    Description: S3 bucket where Lambda zip is stored
  LambdaCodeKey:
    Type: String
    Description: Key (file name) of Lambda zip in S3

Resources:
  ##################################################
  # IAM Role for Lambda
  ##################################################
  StockPriceUpdaterRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${ResourcePrefix}-lambda-role"
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

  ##################################################
  # Lambda Function
  ##################################################
  StockPriceUpdaterFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: !Sub "${ResourcePrefix}-function"
      Handler: StockPriceUpdater::StockPriceUpdater.Function::InvokeAsync
      Role: !GetAtt StockPriceUpdaterRole.Arn
      Runtime: dotnet8
      Timeout: 600 # 10 minutes (max is 900 = 15 minutes)
      MemorySize: 512
      Code:
        S3Bucket: !Ref LambdaCodeBucket
        S3Key: !Ref LambdaCodeKey

  ##################################################
  # Dead Letter Queue (DLQ)
  ##################################################
  StockPriceUpdaterDLQ:
    Type: AWS::SQS::Queue
    Properties:
      QueueName: !Sub "${ResourcePrefix}-dlq"
      MessageRetentionPeriod: 1209600 # 14 days

  ##################################################
  # Role for EventBridge Scheduler
  ##################################################
  SchedulerInvokeRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${ResourcePrefix}-scheduler-role"
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: "Allow"
            Principal:
              Service: "scheduler.amazonaws.com"
            Action: "sts:AssumeRole"
      Policies:
        - PolicyName: SchedulerInvokeLambdaAndDLQ
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: "Allow"
                Action: "lambda:InvokeFunction"
                Resource: !GetAtt StockPriceUpdaterFunction.Arn
              - Effect: "Allow"
                Action: "sqs:SendMessage"
                Resource: !GetAtt StockPriceUpdaterDLQ.Arn

  ##################################################
  # EventBridge Scheduler
  ##################################################
  StockPriceUpdaterSchedule:
    Type: AWS::Scheduler::Schedule
    Properties:
      Name: !Sub "${ResourcePrefix}-scheduler"
      Description: "Triggers the Lambda every 10 minutes"
      FlexibleTimeWindow:
        Mode: "OFF"
      ScheduleExpression: "rate(10 minutes)"
      State: "ENABLED"
      Target:
        Arn: !GetAtt StockPriceUpdaterFunction.Arn
        RoleArn: !GetAtt SchedulerInvokeRole.Arn
        DeadLetterConfig:
          Arn: !GetAtt StockPriceUpdaterDLQ.Arn
        Input: |
          {
            "JobType": "StockUpdate",
            "Payload": { "AccountCode": "Primary" }
          }

Outputs:
  LambdaFunctionName:
    Value: !Ref StockPriceUpdaterFunction
    Description: Name of the Lambda function

🚀 Step 3. Package and Deploy

Package the Lambda

dotnet lambda package --output-package ./StockPriceUpdater.zip
aws s3 cp ./StockPriceUpdater.zip s3://your-bucket/

Deploy the stack

aws cloudformation deploy \
  --template-file stock-price-updater.yml \
  --stack-name StockPriceUpdater \
  --capabilities CAPABILITY_IAM \
  --parameter-overrides \
      ResourcePrefix=stock-updater \
      LambdaCodeBucket=your-bucket \
      LambdaCodeKey=StockPriceUpdater.zip

🧾 Step 4. Verify It Works

After deployment:

Go to Amazon EventBridge → Scheduler → Schedules — you’ll see one schedule.
Open CloudWatch Logs for your Lambda and verify logs every 10 minutes:

[StockPriceUpdater] Triggered for JobType: StockUpdate
AccountCode: Primary
[StockUpdate] Simulated stock price: $74.82 at 2025-10-27T09:00:00Z

Failures are sent automatically to the DLQ (SQS).

⚠️ Lambda Execution Time Limit (15 Minutes)

AWS Lambda has a hard timeout limit of 15 minutes per execution.

If your background job might exceed this:

Step Functions: Chain multiple Lambdas or tasks with retries and parallel steps.
AWS Fargate: Run containerized tasks without worrying about execution time.
AWS Batch: Run large-scale batch jobs with automatic compute scaling.

For long-running tasks, replace Lambda with Step Functions, Fargate, or Batch triggered by EventBridge Scheduler.

🧭 Wrapping Up

You learned how to:

Use EventBridge Scheduler to trigger a .NET Lambda periodically
Handle failures with an SQS DLQ
Deploy everything with CloudFormation

This approach is serverless, scalable, and fully managed, ideal for background jobs, periodic updates, or monitoring tasks.

✅ Key Takeaways

Feature	Description
EventBridge Scheduler	Replaces cron jobs with a managed scheduler
Lambda	Ideal for short, frequent tasks
DLQ (SQS)	Captures failed events for later inspection
CloudFormation	Declarative, repeatable deployments
Limit	Max Lambda duration = 15 minutes — use Step Functions, Fargate, or Batch for longer jobs

Building a Product Entity CRUD Application in Spring Boot for .NET Developers

Bassem Hussein — Thu, 02 Jan 2025 16:14:06 +0000

After exploring the basics of Spring Boot 3 in the previous post, let’s dive deeper by implementing a Product entity CRUD (Create, Read, Update, Delete) operation. Along the way, we’ll compare core Spring Boot concepts with their .NET Core counterparts to help bridge the gap for .NET developers transitioning to the Java ecosystem.

Setting Up the Project

Before starting, ensure you have a Spring Boot project ready with the following dependencies:

Spring Web: For building REST APIs.
Spring Data JPA: For database interactions.
PostgreSQL Driver: For connecting to a PostgreSQL database.

Run PostgreSQL Locally Using Docker

To run PostgreSQL locally, use Docker to quickly set up an instance:

Pull the PostgreSQL image:
```
docker pull postgres
```

Run a PostgreSQL container:

docker run --name postgres-db -e POSTGRES_PASSWORD=yourpassword -e POSTGRES_USER=yourusername -e POSTGRES_DB=mydatabase -p 5432:5432 -d postgres

Replace yourusername, yourpassword, and mydatabase with your desired username, password, and database name.

Verify the database is running:
```
docker ps
```
Use a database client (e.g., DBeaver, pgAdmin, or psql) to connect to localhost:5432 and verify your database is accessible.

Update the `pom.xml` File

If you are using Maven, include the following dependencies in your pom.xml file to ensure all necessary libraries are available:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.5.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Also, ensure the following plugin is included for building the project:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Comparison with .NET Core:
In .NET Core, package references are managed using the csproj file. Equivalent dependencies for a PostgreSQL-backed web API might look like this:

<ItemGroup>
  <PackageReference Include="Microsoft.AspNetCore.App" />
  <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.0" />
</ItemGroup>

Configure PostgreSQL Database

Update your application.yml file to connect to a PostgreSQL database:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydatabase
    username: yourusername
    password: yourpassword
  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: update

Replace mydatabase, yourusername, and yourpassword with your actual PostgreSQL database details. The ddl-auto=update setting ensures that Hibernate creates or updates tables automatically based on your entity definitions.

Comparison with .NET Core:
In .NET Core, similar configurations would reside in appsettings.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=mydatabase;Username=yourusername;Password=yourpassword"
  },
  "EntityFramework": {
    "MigrationsAssembly": "YourProjectName"
  }
}

Project Structure Overview

Spring Boot projects organize code into packages:

entity: Contains data models.
repository: Interfaces for database operations.
controller: REST endpoints.
service (optional): Business logic.

This structure is similar to the typical layers in a .NET Core project: Models, Data/Repositories, Controllers, and Services.

Step 1: Define the Product Entity

In Spring Boot, entities represent database tables, similar to models in Entity Framework Core. Use annotations like @Entity and @Id to map the class to a table:

package com.example.demo.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String description;
    private Double price;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

.NET Core Equivalent

public class Product
{
    public long Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public double Price { get; set; }
}

Step 2: Create a Repository

In Spring Boot, repositories are interfaces extending JpaRepository. They provide built-in CRUD operations, akin to DbContext in EF Core.

package com.example.demo.repository;

import com.example.demo.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

.NET Core Equivalent

public class ProductRepository
{
    private readonly DbContext _context;

    public ProductRepository(DbContext context)
    {
        _context = context;
    }

    public async Task<List<Product>> GetAllAsync() => await _context.Products.ToListAsync();

    // Other CRUD methods
}

Step 3: Implement a Service Layer (Optional)

The service layer handles business logic. While optional, it’s a good practice for larger applications.

package com.example.demo.service;

import com.example.demo.entity.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    public Optional<Product> getProductById(Long id) {
        return productRepository.findById(id);
    }

    public Product saveProduct(Product product) {
        return productRepository.save(product);
    }

    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
}

.NET Core Equivalent

public class ProductService
{
    private readonly ProductRepository _repository;

    public ProductService(ProductRepository repository)
    {
        _repository = repository;
    }

    public async Task<List<Product>> GetAllProductsAsync() => await _repository.GetAllAsync();

    // Other methods
}

Step 4: Build the Controller

Controllers handle HTTP requests, just like in ASP.NET Core.

package com.example.demo.controller;

import com.example.demo.entity.Product;
import com.example.demo.service.ProductService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        Optional<Product> product = productService.getProductById(id);
        return product.map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return productService.saveProduct(product);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
        return ResponseEntity.noContent().build();
    }
}

.NET Core Equivalent

[ApiController]
[Route("api/products")]
public class ProductController : ControllerBase
{
    private readonly ProductService _service;

    public ProductController(ProductService service)
    {
        _service = service;
    }

    [HttpGet]
    public async Task<IActionResult> GetAllProducts() => Ok(await _service.GetAllProductsAsync());

    [HttpGet("{id}")]
    public async Task<IActionResult> GetProductById(long id)
    {
        var product = await _service.GetProductByIdAsync(id);
        return product == null ? NotFound() : Ok(product);
    }

    [HttpPost]
    public async Task<IActionResult> CreateProduct([FromBody] Product product)
    {
        var createdProduct = await _service.SaveProductAsync(product);
        return CreatedAtAction(nameof(GetProductById), new { id = createdProduct.Id }, createdProduct);
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteProduct(long id)
    {
        await _service.DeleteProductAsync(id);
        return NoContent();
    }
}

Step 5: Testing Your API

Run your application and test the endpoints using tools like Postman or cURL. Ensure your PostgreSQL database is running and properly configured.

Once the application is up and running, test the CRUD endpoints with Postman or cURL. Ensure PostgreSQL is running and correctly configured.

Testing Endpoints with Postman:

GET /api/products: Fetch all products.
GET /api/products/{id}: Fetch a single product by ID.
POST /api/products: Create a new product.
DELETE /api/products/{id}: Delete a product by ID.

Key Comparisons

Feature	Spring Boot 3	.NET Core
Dependency Injection	Built-in with `@Autowired` or constructor injection	Built-in with `AddScoped`, `AddSingleton`
ORM Tool	Spring Data JPA	Entity Framework Core
Routing	`@RequestMapping`, `@GetMapping`	`[Route]`, `[HttpGet]`
Middleware	Spring Interceptors	ASP.NET Middleware
Response Handling	`ResponseEntity`	IActionResult

Conclusion

Creating a CRUD application in Spring Boot is simple, especially for those familiar with .NET Core. The principles of dependency injection, ORM, and RESTful APIs are similar in both ecosystems. This guide is just the start—future posts will cover Lombok integration, Swagger/OpenAPI, validation, error handling, and database migrations. Stay tuned!

Happy coding!

References

Spring Boot Documentation: https://spring.io/projects/spring-boot
PostgreSQL Documentation: https://www.postgresql.org/docs/
Spring Data JPA Documentation: https://spring.io/projects/spring-data-jpa
.NET Core Documentation: https://docs.microsoft.com/en-us/aspnet/core/?view=aspnetcore-7.0

Getting Started with Spring Boot 3 for .NET Developers

Bassem Hussein — Mon, 30 Dec 2024 12:24:16 +0000

Here is a list of following posts

Building a Product Entity CRUD Application in Spring Boot

I have been working with .NET since 2008; however, I recently started working in a team that primarily uses Java as the standard back-end language. Transitioning from .NET to Java can be both exciting and challenging.

For this guide, you’ll need some basic knowledge of Java to get started.

Spring Boot 3, a popular framework for building Java applications, offers many similarities to .NET frameworks like .NET Core. This guide will help you bridge the gap and take your first steps into the Spring Boot ecosystem.

Why Spring Boot 3?

Spring Boot 3 simplifies Java application development, just like ASP.NET Core does for .NET. Here’s why it might intrigue you:

Minimal Configuration: Opinionated defaults for rapid development.
Native Support: Build lightweight, native executables with GraalVM.
Wide Adoption: A mature ecosystem with robust libraries and tools.
Java 17+: Leverages modern Java features, much like how .NET embraces modern C#.

Step 1: Set Up Your Environment

Ensure you have the following:

Java 17 or later: Spring Boot 3 requires it. Think of it as the .NET 6 equivalent.
Maven or Gradle: Build tools similar to MSBuild.
An IDE like IntelliJ IDEA (similar to Visual Studio).

Verify your Java installation by running:

java -version

Step 2: Create a New Spring Boot Project

Spring Boot projects are typically initialized through Spring Initializr (akin to the .NET CLI project templates).

Option 1: Using Spring Initializr

Visit Spring Initializr.
Select:
- Project: Maven or Gradle (like choosing NuGet).
- Language: Java.
- Spring Boot Version: 3.x.x.
Add dependencies:
- Spring Web: Equivalent to ASP.NET Core for building REST APIs.
- Spring Data JPA: Similar to Entity Framework Core for database interactions.
- Spring Boot DevTools: Like Hot Reload in Visual Studio.
Download and import the project into IntelliJ or Eclipse.

Option 2: Use Your IDE

Many IDEs support project initialization directly, similar to creating a new project in Visual Studio.

Step 3: Explore the Project Structure

Here’s how a typical Spring Boot project maps to a .NET Core project:

src/main/java: Contains your controllers, services, and entities. Equivalent to the Controllers, Models, and Services folders in ASP.NET.
src/main/resources: Configuration files like application.properties. Think of it like appsettings.json.
pom.xml or build.gradle: Manages dependencies, similar to .csproj.

Step 4: Build Your First REST API

Create a simple REST API in Spring Boot:

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello from Spring Boot 3!";
    }
}

.NET Equivalent:

[ApiController]
[Route("[controller]")]
public class HelloController : ControllerBase
{
    [HttpGet("hello")]
    public IActionResult SayHello()
    {
        return Ok("Hello from ASP.NET Core!");
    }
}

Step 5: Run the Application

In Spring Boot, running the application is as simple as executing a command:

./mvnw spring-boot:run   # For Maven
./gradlew bootRun        # For Gradle

Navigate to http://localhost:8080/hello to see your API in action.

Step 6: Comparing Core Concepts

Here’s a quick comparison of familiar .NET Core concepts and their Spring Boot equivalents:

.NET Core Concept	Spring Boot Equivalent
ASP.NET Middleware	Spring Interceptors & Filters
Dependency Injection	Built-in DI Container
Entity Framework Core	Spring Data JPA
appsettings.json	application.properties or YAML
NuGet	Maven or Gradle

Step 7: Expand Your Application

Database Integration: Use Spring Data JPA to connect to a database, much like using EF Core.
Security: Add Spring Security for authentication and authorization, similar to ASP.NET Identity.
Observability: Use Spring Actuator for health checks and metrics, similar to .NET HealthChecks.

Step 8: Debugging and Hot Reload

Spring Boot’s DevTools provides hot-reloading, akin to .NET’s Hot Reload feature. Add spring-boot-devtools as a dependency to your project.

References

Spring Initializr: https://start.spring.io/
Spring Boot Documentation: https://docs.spring.io/spring-boot/docs/current/reference/html/
Java 17 Documentation: https://openjdk.org/projects/jdk/17/
Spring Framework 6: https://spring.io/projects/spring-framework
GraalVM Documentation: https://www.graalvm.org/
ASP.NET Core Overview: https://learn.microsoft.com/en-us/aspnet/core/

Conclusion

For .NET developers, learning Spring Boot 3 is a natural transition. Many concepts like dependency injection, REST APIs, and ORM tools are similar, allowing you to quickly adapt and leverage the strengths of the Java ecosystem.

I will create a series of posts following this guide to demonstrate how to put all these concepts into action by building a REST API for a product catalog. Stay tuned!

If you have any questions, I am glad to help.

Happy coding!

DEV Community: Bassem Hussein

🕒 Automating Periodic Tasks with EventBridge Scheduler, .NET, and CloudFormation

🧩 What You’ll Build

⚙️ Step 1. Create a .NET Lambda Function

🧱 Project Setup

🧠 Function Code (Function.cs)

📜 Step 2. Deploy with CloudFormation

🚀 Step 3. Package and Deploy

🧾 Step 4. Verify It Works

⚠️ Lambda Execution Time Limit (15 Minutes)

🧭 Wrapping Up

✅ Key Takeaways

Building a Product Entity CRUD Application in Spring Boot for .NET Developers

Setting Up the Project

Run PostgreSQL Locally Using Docker

Update the pom.xml File

Configure PostgreSQL Database

Project Structure Overview

Step 1: Define the Product Entity

Step 2: Create a Repository

Step 3: Implement a Service Layer (Optional)

Step 4: Build the Controller

Step 5: Testing Your API

Testing Endpoints with Postman:

Key Comparisons

Conclusion

References

Getting Started with Spring Boot 3 for .NET Developers

Why Spring Boot 3?

Step 1: Set Up Your Environment

Step 2: Create a New Spring Boot Project

Option 1: Using Spring Initializr

Option 2: Use Your IDE

Step 3: Explore the Project Structure

Step 4: Build Your First REST API

Step 5: Run the Application

Step 6: Comparing Core Concepts

Step 7: Expand Your Application

Step 8: Debugging and Hot Reload

References

Conclusion

🧠 Function Code (`Function.cs`)

Update the `pom.xml` File