DEV Community: Felipe Jansen

LocalStack: Speeding Up Cloud Development Without Leaving Your Machine

Felipe Jansen — Tue, 20 Jan 2026 13:48:16 +0000

LocalStack: Speeding Up Cloud Development Without Leaving Your Machine

When building cloud-native applications, one of the biggest productivity killers is the constant dependency on real cloud environments for development and testing.

That’s where LocalStack really shines.

LocalStack allows you to run AWS services locally, simulating resources like S3, DynamoDB, Lambda, API Gateway, SQS, SNS, and many others. This means you can develop, test, and debug your applications without deploying every change to AWS.

Why LocalStack makes a difference

From my experience, using LocalStack brings several practical benefits:

Faster feedback loops: no network latency, no waiting for cloud resources
Lower costs: avoid unnecessary AWS usage during development
Production-like environments: fewer surprises when deploying
Better CI/CD integration: easier to run automated tests locally and in pipelines

It’s especially useful when working with microservices, event-driven architectures, and serverless applications, where multiple AWS services interact with each other.

Local development that scales

By combining LocalStack with tools like Docker, Docker Compose, and infrastructure-as-code solutions, teams can create repeatable and reliable local environments that closely mirror

Getting Hands-On with LocalStack: AWS Development on Your Local Machine

When working with AWS-based applications, deploying every small change just to test an integration can be slow, expensive, and frustrating. LocalStack solves this by allowing you to run AWS services locally and test your cloud architecture without leaving your machine.

This post walks through a practical LocalStack setup and shows how it fits into a real development workflow.

1. Running LocalStack with Docker

The easiest way to get started is by using Docker Compose.

version: "3.8"
services:
  localstack:
    image: localstack/localstack
    ports:
      - "4566:4566"
    environment:
      - SERVICES=s3,dynamodb,lambda,apigateway
      - AWS_DEFAULT_REGION=us-east-1
      - AWS_ACCESS_KEY_ID=test
      - AWS_SECRET_ACCESS_KEY=test
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock"

Start LocalStack with:

docker-compose up

All AWS services will be available through a single endpoint:

http://localhost:4566

2. Creating Resources Locally

You can interact with LocalStack using the AWS CLI.

Create an S3 bucket

aws --endpoint-url=http://localhost:4566 s3 mb s3://local-bucket

Create a DynamoDB table

aws --endpoint-url=http://localhost:4566 dynamodb create-table \
  --table-name Users \
  --attribute-definitions AttributeName=id,AttributeType=S \
  --key-schema AttributeName=id,KeyType=HASH \
  --billing-mode PAY_PER_REQUEST

This setup behaves just like AWS — but runs entirely locally.

3. Using LocalStack with a Java (Spring Boot) Application

In a Spring Boot application, you only need to override the AWS endpoint in your configuration.

cloud:
  aws:
    region:
      static: us-east-1
    credentials:
      access-key: test
      secret-key: test
    endpoint:
      dynamodb: http://localhost:4566

Your AWS SDK clients and repositories will work exactly the same way as in production.

4. Testing Event-Driven and Serverless Flows

LocalStack is especially powerful for:

Lambda + API Gateway
SQS / SNS messaging
DynamoDB Streams

You can deploy Lambdas locally, trigger them via API Gateway, and debug the full flow without touching AWS.

This makes it ideal for:

Integration tests
Local debugging
CI/CD pipelines

5. Why This Matters in Real Projects

Using LocalStack in real projects helped me:

Reduce feedback time from minutes to seconds
Catch integration issues earlier
Keep local and CI environments aligned
Increase confidence before deploying to production

LocalStack shifts cloud development from “deploy and pray” to “test locally with confidence”.

Final Thoughts

LocalStack isn’t just a mock — it’s a local cloud environment.

If you work with AWS, microservices, or serverless architectures, investing time in a solid LocalStack setup pays off quickly in productivity and software quality.

Overview of Angular Signals

Felipe Jansen — Mon, 23 Jun 2025 15:01:54 +0000

🔔 Angular Core Signals Overview

Angular Signals is a new reactivity system in Angular designed to optimize how an application tracks and responds to state changes. Signals simplify how state updates propagate and allow Angular to minimize unnecessary re-renders by targeting only the components or views that actually depend on the changed data.

🛠️ What is a Signal?

A signal is a lightweight reactive wrapper around a value. It notifies any interested consumer (such as templates or computed functions) whenever its value changes. This allows Angular to automatically and efficiently track dependencies in your application.

📌 Types of Signals

Writable Signals: Can be updated directly. You create them using the signal() function:

  const counter = signal(0); // Initial value 0
  counter.set(3);            // Set to 3
  counter.update(value => value + 1); // Increment

Read-only Signals: Expose only a getter and cannot be modified directly from outside.
Computed Signals: A special type of signal whose value is derived (computed) from other signals. Whenever the dependencies change, the computed signal is reactively updated.
```
import { computed } from '@angular/core';
const doubled = computed(() => count() * 2); // This recalculates whenever `count` changes
```

⚙️ How Signals Work

Dependency Tracking: When a signal's getter is invoked in a reactive context (such as an Angular template), Angular registers this context as a dependent. Whenever the signal's value changes, Angular knows exactly which parts of the UI or application logic need to be updated.
Equality Checking: You can provide an equality comparator when creating a signal. If the comparator determines that a new value is equal to the current value, Angular will not propagate the change, minimizing unnecessary work.

🔍 Usage Example

Here's a simple example of a counter component using signals:

@Component({
  selector: "app",
  template: `
    <h1>Current value of the counter {{ counter() }}</h1>
    <button (click)="increment()">Increment</button>
  `
})
export class AppComponent {
  counter = signal(0);

  increment() {
    this.counter.set(this.counter() + 1);
  }
}

In this example, the UI is automatically and efficiently updated only when the counter signal changes, without the need for manual input tracking or complex change detection logic.

🚀 Advantages of Signals in Angular

Fine-grained Reactivity: Only parts of the UI directly dependent on changed signals are re-rendered.
Declarative State Management: Code becomes clearer and more predictable.
Performance: Reduces unnecessary DOM updates and change detection cycles.
Explicit Dependency Declaration: Signals are automatically tracked in reactive contexts.

Summary Table

Primitive	Purpose	How it's used
signal	Holds a writable or read-only value	`const s = signal(initialValue)`
computed	Derives value from other signals	`const c = computed(() => s() * 2)`
effect	Responds to changes in one or more signals	`effect(() => doSomething(s()))`

🔍 Heap Memory vs. Stack Memory in Java: What’s the Difference?

Felipe Jansen — Thu, 15 Aug 2024 04:06:33 +0000

When it comes to memory management in Java, two fundamental concepts that every developer should understand are Heap Memory and Stack Memory. Grasping the difference between these two is crucial for writing efficient code and avoiding issues like memory leaks or overflow.

💡 Stack Memory
Stack Memory is used to store local variables and method calls. Each time a method is invoked, a new "stack frame" is created to store the method's variables and the return address. Once the method completes, the frame is removed, instantly freeing up the memory. The Stack is highly efficient but limited in size.

📂 Heap Memory
Heap Memory, on the other hand, is where objects in Java are stored. Unlike the Stack, the Heap has a larger size and allows for dynamic memory allocation. Objects allocated on the Heap remain there until there are no more references to them, at which point the Garbage Collector kicks in to free up that memory. The Heap is more flexible, but accessing it is slightly slower compared to the Stack.

⚖️ Why Does It Matter?
Understanding how Stack and Heap memory work can help you optimize resource usage and avoid issues like StackOverflowError (when the Stack is full) or OutOfMemoryError (when the Heap can't allocate more objects). Knowing when and where to allocate memory is essential for creating robust and efficient Java applications.

Java #Programming #SoftwareDevelopment #MemoryManagement #HeapVsStack

🎓 Understanding the Difference Between Checked and Unchecked Exceptions in Java 🚀

Felipe Jansen — Mon, 12 Aug 2024 14:57:07 +0000

If you've worked with Java, you've certainly encountered exceptions.

But do you know the difference between checked and unchecked exceptions? 🤔

🔍 Checked Exceptions: These are exceptions that the compiler forces you to handle. They typically represent conditions that can occur due to factors outside the program's control, like network issues 🌐 or I/O failures 📝. For example, when trying to open a file that doesn’t exist, a FileNotFoundException is thrown.

As a developer, you must either handle these exceptions (using a try-catch block) or declare that the method can throw them (using throws in the method signature).

🔍 Unchecked Exceptions: These exceptions are subclasses of RuntimeException and are not checked by the compiler. They usually indicate programming errors, such as trying to access an array index out of bounds (ArrayIndexOutOfBoundsException) 🛑 or dividing by zero (ArithmeticException).

Since they aren't mandatory to handle, you can choose to catch them or let them propagate.

⚖️ When to Use Which?

Use checked exceptions for situations where failure is expected and recoverable 🔄.

Use unchecked exceptions to indicate programming errors that ideally should be fixed rather than handled 🛠️.

Understanding this difference helps you write more robust code 💪 and make better decisions when dealing with errors. How do you usually handle exceptions in your code? Share your experiences in the comments! 💬

Java #Programming #SoftwareDevelopment #Exceptions #CodingBestPractices

🔍 Understanding the Differences: List, ArrayList, and LinkedList in Java 🔍

Felipe Jansen — Thu, 08 Aug 2024 20:23:01 +0000

As developers, we work with different data structures daily. In the Java ecosystem, three of the most commonly used are List, ArrayList, and LinkedList.

While they might seem similar at first glance, each has its peculiarities and specific uses. Let’s dive deeper:

☑ List

List is an interface in the Java Collection Framework that extends Collection. It defines an ordered collection type that allows duplicate elements. Some key operations include addition, removal, search, and iteration. List serves as the base for many implementations, including ArrayList and LinkedList.

☑ ArrayList

ArrayList is an implementation of the List interface based on a dynamic array. Some important characteristics include:

Fast Access: Element access is very fast (O(1)) due to the array index.
Dynamic Growth: Automatically grows as new elements are added.
Slow Insertion and Removal: Inserting or removing elements in the middle of the list can be costly (O(n)) due to the shifting of elements.

🌟 When to use: When you need fast access and are not concerned with frequent insertions or deletions of elements in the middle of the list.

☑ LinkedList

LinkedList also implements the List interface but is based on a doubly linked list data structure. Some important characteristics include:

Fast Insertion and Removal: Insertions and deletions are efficient (O(1)) at the ends (beginning and end) of the list.
Slow Access: Accessing elements is slower (O(n)) because it requires iterating through the nodes.
Flexibility: Can be used as a queue or deque (double-ended queue) due to its linked nature.

🌟 When to use: When the application requires many insertions and deletions of elements, especially at the beginning or end of the list, and fast random access is not critical.

🎯 Conclusion

Choosing between ArrayList and LinkedList depends on the specific use case of your application. Understanding the characteristics of each implementation can help you optimize your code's performance and efficiency. Knowledge is power! 🚀

I hope this helps clarify the differences and aids you in making the right choice for your next project! If you have questions or want to discuss more about data structures in Java, drop a comment below! 👇

Java #Development #DataStructures #Programming #SoftwareDevelopment

🔍 Understanding the N+1 Problem: A Common Performance Pitfall in Database Queries 🛠️

Felipe Jansen — Wed, 07 Aug 2024 17:59:49 +0000

As developers, we've all encountered performance bottlenecks that can be tricky to diagnose and solve. One such issue is the N+1 problem, a common yet often overlooked challenge in database query optimization.

So, what is the N+1 problem? 🤔 It occurs when your application makes an initial query to retrieve a list of items (say, users) and then makes additional queries for each item to fetch related data (like each user's posts). This results in N+1 queries—one for the initial list and one for each item in that list.

Imagine you have 100 users, and for each user, you need to fetch their posts. Instead of 1 query to get all users and 1 more to get all posts, you end up with 1 query for users + 100 queries for posts. 📈 This inefficiency can lead to significant performance issues, increasing latency and putting unnecessary load on your database. 💾

🔧 How can we tackle the N+1 problem?

Eager Loading: Fetch all required data in a single query using joins or includes, reducing the number of queries.
Batch Processing: Group related queries together to minimize database round-trips.
Query Optimization: Regularly review and optimize your queries to ensure they're as efficient as possible.

Addressing the N+1 problem is crucial for improving application performance and providing a smoother user experience. Let’s stay vigilant and proactive in identifying and solving these issues to build faster, more efficient applications. 🚀

SoftwareDevelopment #DatabaseOptimization #PerformanceTuning #CodingTips #DeveloperLife #TechTips #Programming

🚀 Understanding Map and HashMap in Java 🚀

Felipe Jansen — Tue, 06 Aug 2024 03:30:04 +0000

Have you ever wondered how to efficiently store key-value pairs in Java? 🤔 If so, let's talk about two essential structures: Map and HashMap.

🔍 What is a Map?
Map is an interface in Java that represents a collection of key-value pairs, where each key is unique. This means you can use Map to map a specific key to a specific value, allowing for quick and efficient lookups.

🌟 Introducing HashMap
HashMap is a concrete implementation of the Map interface, based on the hash table data structure. It offers:

O(1) complexity for insertion and lookup operations in most cases.
Flexibility: allows null as a key and value.
Performance: ideal for scenarios where the order of keys is not relevant.

🚀 Benefits of HashMap:

Efficiency: Fast insertion, removal, and lookup operations.
Simplicity: Easy to use and implement.
Versatility: Can store any type of data.

⚠️ Points to Consider:

Unordered: The order of elements is not guaranteed.
Synchronization: Not thread-safe by default. Use Collections.synchronizedMap for synchronization.

Understanding these structures can take your Java knowledge to the next level, providing more efficient and elegant solutions! 💼💡

Share your experiences with Map and HashMap in the comments! 👇

How we can create a Pix Qrcode using Java ☕ and Spring 🍃

Felipe Jansen — Mon, 29 Jul 2024 19:48:14 +0000

Hey everyone! Good morning, good afternoon, and good evening!!! Let’s talk about money! #letstalkaboutmoney

In this post, I'll show you how to create a Pix code and then generate a QR code from it. Let’s dive in! 🚀📲

Creating a Pix code is pretty straightforward, but it’s worth checking out BACEN’s documentation. Since they’re behind Pix, it’s a good idea to follow their guidelines. 😉📋

For that, here’s the guide we’ll be using: https://www.bcb.gov.br/content/estabilidadefinanceira/pix/Regulamento_Pix/II_ManualdePadroesparaIniciacaodoPix.pdf. Check it out! 📚

If you’re panicking about your feature’s deadline and can’t squeeze in time for the documentation, don’t worry—I’ll break down the key points for you right here… 😉

Below is an example of a Pix code generated from the table above. If you look closely, you'll see it's pretty straightforward—just follow the info from the table. Also, keep in mind that the most likely things to change are the Pix key and the amount.

Without further ado, let’s get to the point.

The format is ID + Tam + Valor, and we’ll be concatenating the information. Additionally, some fields require you to include both the information and the string length. This applies specifically to Merchant Account Information, Transaction Currency, and Merchant City.

PS.: The details that change most often are the key (which is the Pix key itself), Transaction Currency, Merchant Name, and Merchant City. You’ll need to replace these with the Pix key, the amount, the name of the recipient, and the recipient's city.

PS. 2: After completing the procedure, we need to make sure the code is valid. To do this, we’ll run a Cyclic Redundancy Check (CRC) on it (https://en.wikipedia.org/wiki/Cyclic_redundancy_check) and append the generated CRC code to the end of the Pix code. This will validate the Pix code. The Java code for this is provided below.

PS 3 .: The txid field refers to the Pix description field—the message field provided by BACEN that lets us send messages with our Pix transactions.

private static String CRC16CCITT(String payload) {
        int crc = 0xFFFF;          // initial value
        int polynomial = 0x1021;   // 0001 0000 0010 0001  (0, 5, 12)

        byte[] bytes = payload.getBytes(Charset.defaultCharset());

        for (byte b : bytes) {
            for (int i = 0; i < 8; i++) {
                boolean bit = ((b   >> (7-i) & 1) == 1);
                boolean c15 = ((crc >> 15    & 1) == 1);
                crc <<= 1;
                if (c15 ^ bit) crc ^= polynomial;
            }
        }

        crc &= 0xffff;
        return Integer.toHexString(crc);
    }

That’s it—this is how you create a Pix code. To generate the QR code, just take the text and plug it into your preferred QR code generator. I like using QR Code Generator.

Useful Links:

Explanation of CRC16: All You Need to Know About CRC16 - Detecting Errors in Data Transmission
CRC on Wikipedia: Cyclic Redundancy Check (CRC)
Link for repository of this project: PixService.java

Follow me on Linkedin for more: https://www.linkedin.com/in/felipe-neiva-jansen/

Passing erros throught microsservices (Java + Spring)

Felipe Jansen — Thu, 11 Jul 2024 03:11:10 +0000

Hey folks! Here's another quick tip for you: today, we're diving into handling exceptions in Java and how we can smoothly manage errors across microservices (among other approaches). Let's learn together! 👨‍💻🚀

Some time ago, I came across an issue where I needed to pass an error to the BFF (Backend-for-frontend). In essence, we have three microservices: one BFF, and others that handle the business logic of the application. Errors triggered within the business logic need to at least return a message to the BFF. This allows the frontend to determine the best error message and the most appropriate way to handle that specific error.

In short, the approach is quite straightforward: the server sends an error code through a header, and both the frontend and BFF are responsible for reading this code and returning a formatted JSON response to the frontend. Here are the steps:

Trigger an exception on the server, passing the error code.
The ExceptionHandler handles this exception and inserts the error code into a header called "CODE".
On the BFF side, this error is captured and a JSON response is constructed to be sent back to the frontend.

Here's a rough outline of how the code might look:

@Service
public class ServerService {

    public Sucesso testMethod(Long id) {
        if (id == 1) {
            throw new ServerException(HttpStatus.BAD_REQUEST, ERROR_001);
        } else if (id == 2) {
            throw new ServerException(HttpStatus.BAD_REQUEST, ERROR_002);
        } else if (id == 3) {
            throw new ServerException(HttpStatus.BAD_REQUEST, ERROR_003);
        }
        return Sucesso.builder().id(id).build();
    }
}

Afterward, on the server side, this is the class responsible for handling triggered errors and adding the error code into the respective header!

@RestControllerAdvice
public class ControlExceptionHandler {

    public static final String CODE = "CODE";

    @ExceptionHandler({ServerException.class})
    public ResponseEntity<Object> serverException(ServerException e) {
        HttpHeaders responseHeaders = new HttpHeaders();
        responseHeaders.add(CODE, e.getCode());
        return ResponseEntity.status(e.getHttpStatusCode()).headers(responseHeaders).build();
    }

}

On our BFF side, we use the .onStatus() method to check if an error occurred in the request and take appropriate actions (in this case, throwing a ClientException based on the obtained response)."

@Service
public class ServerService {

    public static final String CODE = "CODE";
    private final RestClient restClient;

    public ServerService(RestClient restClient) {
        this.restClient = restClient;
    }

    public Sucesso testMethod(Long id) {
        return restClient
                .get()
                .uri("http://localhost:8080?id=" + id)
                .retrieve()
                .onStatus(HttpStatusCode::isError, (HttpRequest request, ClientHttpResponse response) -> {
                    throw new ClientException(HttpStatus.BAD_REQUEST, Objects.requireNonNull(response.getHeaders().get(CODE)).get(0));
                })
                .body(Sucesso.class);
    }
}

And then, still on the BFF side, we construct the response for the Frontend based on the header captured from the response.

@RestControllerAdvice
public class ControlExceptionHandler {

    @ExceptionHandler({ClientException.class})
    public ResponseEntity<Object> ClientException(ClientException e) {
        return ResponseEntity.status(e.getHttpStatusCode()).body(e.getOnlyBody());
    }

}

Finally, this is the result that we expect.

Here's the code on github: https://github.com/FelipeJansenDev/errors-between-microsservices

Follow me on Linkedin for more tips and tricks: https://www.linkedin.com/in/felipe-neiva-jansen/

Implementing an Interceptor for RestClient (Java + Spring Boot)

Felipe Jansen — Tue, 25 Jun 2024 15:23:33 +0000

Hello, everyone! Today, I'll be showing you a straightforward way to set up an interceptor in the new RestClient class of the Spring Framework.

1º) First, let's create our project. We'll keep it simple, just for study purposes.

2º) Next, let's create our class that will be used as the interceptor.



@Component
public class RestClientInterceptor implements ClientHttpRequestInterceptor {

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        request.getHeaders().add("header1", "header 1 value");
        return execution.execute(request, body);
    }

}

According to the Spring Framework documentation, the ClientHttpRequestInterceptor interface is a contract to intercept client-side HTTP requests. Implementations can be registered with RestClient or RestTemplate to modify the outgoing request and/or the incoming response. The interface contains the method intercept, which intercepts the given request and returns a response. The provided ClientHttpRequestExecution allows the interceptor to pass on the request and response to the next entity in the chain.

3º) Let's configure our RestClient Bean.



@Configuration
public class RestClientConfig {

    @Bean
    RestClient restClient() {
        return RestClient.builder().baseUrl(null).requestInterceptor(new RestClientInterceptor()).build();
    }
}

4º) Now, let's create the classes to test our interceptor. We will need a service class to make HTTP requests and a test class to verify that the interceptor is working correctly.



@Service
public class Client {

    private final org.springframework.web.client.RestClient restClient;

    public Client(org.springframework.web.client.RestClient restClient) {
        this.restClient = restClient;
    }

    public void restClientAct() {
        restClient.post().retrieve();
    }

}



@RestController
@RequestMapping("/")
public class RestClientController {

    private final Client request;

    public RestClientController(Client request) {
        this.request = request;
    }

    @GetMapping()
    public void getAccount(){
        request.restClientAct();
    }

}

5º) Done! Here is the curl command to test the endpoint:

curl --location 'localhost:8080'

I think that's it. This basic code should address your need to intercept requests made from the RestClient.

Here's the code on github: https://github.com/FelipeJansenDev/rest-client-interceptor

Follow me on Linkedin for more tips and tricks: https://www.linkedin.com/in/felipe-neiva-jansen/