DEV Community: Akriti Keswani

Debug Smarter: Multimodal Error Analysis for Next.js with Daft.ai

Akriti Keswani — Wed, 13 Aug 2025 23:19:04 +0000

Late-night debugging? We've all been there.

It’s 11 PM on a Thursday. You should be winding down, but your Next.js app is throwing cryptic hydration errors and 500s are flooding your logs. Your desktop’s cluttered with screenshots and log files, and you're hopping between ChatGPT, Claude, and Cursor hoping someone (or something) can help you connect the dots.

But nothing clicks. The AI doesn’t seem to understand that the broken UI might be linked to that failed API call you saw 10 minutes ago. And now you’re the one trying to piece together the story from screenshots, console logs, and error messages. If this sounds familiar, you're not alone—and you’re definitely not doing anything wrong. The reality is: debugging multimodal errors (text + visual + structured data) is still way harder than it should be.

So, what if you could search your error data like a knowledge base? What if you could say, “Show me all auth errors with matching screenshots,” and get a real answer? In this tutorial, we’ll show you how to do exactly that—with Daft.ai, a framework built to handle and analyze structured + unstructured data at scale. We'll walk through how to:

• Load and process error logs and screenshots
• Generate embeddings for both text and images using UDFs
• Run semantic + similarity search across modalities
• Get insights and recommendations - all from one place

Let’s build a better way to debug!

What We're Building

By the end of this post, you’ll have a fully working multimodal debugging tool that can:

• Ingest logs and screenshots
• Generate embeddings using Daft.ai's UDFs
• Classify errors automatically
• Run similarity search across both text and images
• Answer RAG-style queries with actual context

Step 1: Organize Your Error Data

Start by structuring your Next.js error artifacts like this:

nextjs_errors/
├── screenshots/
│   ├── auth_error.png
│   ├── hydration_error.png
│   ├── runtime_error.png
│   └── build_error.png
└── logs/
    ├── api_auth_error.txt
    ├── hydration_error.txt
    ├── runtime_error.txt
    └── build_error.txt

These can be pulled from Sentry, your browser dev tools, Vercel logs—
wherever your pain lives.

Step 2: Load Logs + Screenshots into Daft

Step 3: Embed Your Data (Text + Image)

Now we’ll write custom UDFs (user-defined functions) to simulate embeddings. These help Daft understand the meaning behind each log or screenshot:

Note: In production, you'd replace these with actual embedding models like OpenAI's text-embedding-ada-002 or CLIP for images.

Step 4: Classify Errors Automatically

Let’s tag our logs with some basic intelligence:

Step 5: Run RAG Queries

You can now run natural queries like:

Step 6: Search for Similar Errors

Want to find logs or screenshots that look like the one you just debugged? Use cosine similarity across your embeddings:

Results

What's Next?

In this tutorial, I chose Next.js as the focus because it's where I spend most of my time as a developer, and honestly, it's where I have the most fun building. But beyond personal passion, the numbers tell a compelling story: with over 5 million developers using Next.js weekly, we're talking about a massive chunk of the global developer experience that's still stuck in manual debugging workflows.
Every week, millions of developers are doing exactly what I described in the intro—copying screenshots into AI assistants, losing context between logs and visual breakdowns, manually connecting dots that should be automated. The scale of this inefficiency is staggering when you think about it globally.

That's what excites me most about this project. We've built a functional multimodal error analysis pipeline with Daft.ai that demonstrates:

• Custom UDFs for embedding generation
• Classification of real-world Next.js error patterns
• Embedding similarity search across modalities
• RAG-style queries over multimodal error datasets
• Insight generation with actionable debugging recommendations

This isn't just a cool technical demo—it's a proof of concept for streamlining debugging workflows for millions of developers. The foundation shows what's possible when you combine Daft's UDF capabilities with real developer pain points at scale.

Final Thoughts

Instead of manually copying screenshots into Cursor and losing context, you can now process your error data programmatically and find patterns across both text logs and visual breakdowns. With Daft.ai, your debugging workflow becomes data-driven—and that efficiency multiplied across developers could fundamentally change how we approach debugging.

👉 See full code on Github!

RAG Pipeline Permissions for iPaaS Platforms

Akriti Keswani — Tue, 20 Aug 2024 21:38:42 +0000

Introduction

The AI revolution in the B2B SaaS world is more intense than ever, with new tools empowering developers to build products that customers not only desire but require. As these SaaS companies grow and scale, managing customer data privacy becomes increasingly complex. How can companies enforce strict access control for each customer while ensuring that the AI components in their SaaS applications use the correct information efficiently and securely?

To visualize these challenges better, one must begin by understanding the value of retrieval-augmented generation, commonly known as RAG in the developer community, which has become a key ingredient for enhancing AI outputs with relevant context. To use RAG in multi-tenant SaaS applications however, poses its own set of hurdles, and perhaps the most critical one is implementing robust permissions.

This article explores the challenges and best practices for managing permissions in RAG pipelines for AI-powered SaaS products. It aims to deep dive into why this is so essential for engineering and product leaders, tackling how to overcome common obstacles and strategize building secure, scalable systems.

To start visualizing these concepts in a more practical way, we can take an example use case of building secure enterprise search, and further handling permissions of users utilizing this feature.

Leveraging iPaaS Platforms for RAG Pipeline Permissions

While implementing robust permissions in a RAG pipeline is complex, embedded iPaaS platforms can significantly accelerate the process. These platforms provide key capabilities that align with the best practices outlined above:

Flexible Authentication

Many iPaaS platforms offer OAuth management, simplifying the process of authenticating users and obtaining the necessary permissions from various data sources like Google Drive, Slack, or Notion.

name: Authenticate Third-Party Service
trigger:
  type: http
  method: GET
steps:
  - name: Initiate OAuth Flow
    action: third_party_service.start_auth
    input:
      redirect_uri: '{{ env.REDIRECT_URI }}'
  - name: Redirect to Service
    action: http.redirect
    input:
      url: '{{ steps.Initiate_OAuth_Flow.output.auth_url }}'

Granular Access Controls

Utilize the iPaaS platform's built-in access control features to implement fine-grained permissions across your RAG pipeline.

name: Check Document Access
trigger:
  type: http
  method: POST
steps:
  - name: Verify User Permission
    action: document_service.check_permission
    input:
      document_id: '{{ trigger.body.document_id }}'
      user_email: '{{ trigger.body.user_email }}'
  - name: Return Access Status
    action: http.respond
    input:
      body:
        has_access: '{{ steps.Verify_User_Permission.output.has_permission }}'

Scalable Processing

Most iPaaS platforms offer cloud-native architectures that can handle high volumes of permission checks and data processing, with built-in error handling and smart rate limiting.

Workflow Automation

Use the iPaaS platform's workflow engine to build complex permission enforcement logic without managing infrastructure.

name: Permission-Aware Search
trigger:
  type: http
  method: POST
steps:
  - name: Perform Search
    action: custom_action.search_documents
    input:
      query: '{{ trigger.body.query }}'
      user_email: '{{ trigger.body.user_email }}'
  - name: Filter Results
    action: custom_action.apply_permission_filter
    input:
      search_results: '{{ steps.Perform_Search.output.results }}'
      user_email: '{{ trigger.body.user_email }}'
  - name: Generate AI Summary
    action: ai_service.generate_summary
    input:
      model: 'advanced_summarization'
      content: 'Summarize: {{ steps.Filter_Results.output.filtered_results }}'
  - name: Return Results
    action: http.respond
    input:
      body:
        results: '{{ steps.Filter_Results.output.filtered_results }}'
        summary: '{{ steps.Generate_AI_Summary.output.summary }}'

Audit Logging

Leverage the iPaaS platform's logging capabilities to maintain detailed audit trails of all data accesses and permission checks.

By using an embedded iPaaS platform, engineering teams can focus on building differentiating AI features rather than reinventing the wheel on permission infrastructure. These platforms' pre-built integrations, scalable architecture, and flexible workflow engines provide a solid foundation for implementing secure, permission-aware RAG pipelines.

Conclusion

Implementing robust permissions in RAG pipelines is crucial for AI-powered B2B SaaS products to deliver secure, compliant, and personalized experiences. While the challenges are significant, a thoughtful approach combining architectural best practices with powerful iPaaS tools can help engineering teams build secure, scalable RAG systems.

As AI becomes increasingly central to SaaS offerings, mastering permissions in RAG pipelines will be a key differentiator. By investing in this capability and leveraging iPaaS platforms, engineering and product leaders can position their products to deliver intelligent, trustworthy AI features while maintaining the strict data controls that enterprise customers demand.

The example of secure enterprise search illustrates the complexity and importance of getting permissions right in RAG pipelines. However, the principles and practices discussed here apply broadly across various AI-powered SaaS applications, from customer support chatbots to data analysis tools. By leveraging iPaaS platforms and following best practices, teams can accelerate their development of secure, scalable AI features that respect the nuanced permission requirements of enterprise environments.

Annotations in Java Spring

Akriti Keswani — Mon, 03 Jun 2024 06:37:29 +0000

For decades as of today, Java is undoubtedly one of the most popular programming languages used at companies with massive codebases. You would think that now with languages such as Kotlin and Scala, companies probably want to pivot and entirely modernize their codebases, but there must be something so special about Java that makes people want to stay and revert to it. I wonder what that is…

Well, one could argue that it is the mere fact of Java being such a popular choice for object-oriented programming and that the JVM makes it so dynamic to run and deploy across complex operating systems. One must also consider though, the sheer flexibility of Java, especially with frameworks such as Spring that leverage containerizing objects and method calls, which essentially make applications easier to scale, which is quite necessary in enterprise software environments.

Let’s get into why Spring is so awesome as a framework, especially when you are dealing with huge codebases that require you to sift through hundreds of services in several interconnected repositories - we have all been there!

So in most normal applications, you definitely need a lot of boilerplate code to get started, especially if you are running a client on top of a server, and Spring makes this seamless with the abstraction and layering of classes, as well as annotations classifying objects, services, and the lines of code actually executing the other lines of code. All that sort of may seem confusing, but here’s the thing, annotations can really enhance the way your code looks, operates, and performs after more code has been written.

So, in Java Spring, it is a known concept to use annotations, which can get pretty tricky fast, because it abstracts away so much code that you would otherwise have to write. Annotations such as @Slf4j (used for logging) can be super confusing to someone who is just starting to write classes in a Spring application. I'm here to tell you that it all gets easier, and makes sense eventually, like all things in life!

Typically, in these Java Spring applications, you usually have a main file that is like the runner, the one that calls the entire application, often denoted with a @SpringBootApplication annotation. In its bare form, this file looks like:

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

In reality @SpringBootApplication is actually a combination of @SpringBootConfiguration (specialized version of @Configuration) @EnableAutoConfiguration, and @ComponentScan. The reason for this is that we need to reduce the boilerplate code and make the code more readable. We can see this in the way that @EnableAutoConfiguration minimizes the need to write configuration code manually. Lastly, @ComponentScan can do the work of registering beans in the application context for the build to work without explicitly declaring each component.

As you can see, each annotation serves a specific purpose, and together they enable the entire application to function. Let's dive deeper into @Repository, another useful annotation that supports storage, retrieval, update, and delete operations on objects. This annotation is a specialization of @Component, which allows Spring to detect and manage repository classes.

Here's an example:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Custom query methods can be defined here
}

In the comment area, you can include custom query logic using the @Query annotation or take advantage of Spring Data JPA's query method conventions. For example, methods like IsStartingWith or Containing can be used to filter data.

A practical example would be:

List<User> findByFirstnameContaining(String fragment);

This method filters users whose first names contain the specified fragment. Using these conventions makes the code more readable and easier to maintain.

All this is great, but in order to do some action on the code and perform operations on how we are using all this data, understanding the @Service annotation is quite necessary. The @Service annotation is used to define a service class in the service layer of the application. This layer contains the business logic and acts on data passed between the controller and repository layers. Services often operate on models or POJO (Plain Old Java Object) objects, which represent the data in your application.

Here's an example of how a service can be structured:

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    // Logic on finding a user by ID
    public User findUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    // Logic on how to create or update a user
    public User saveUser(User user) {
        return userRepository.save(user);
    }
}

Here we see that the @Autowired annotation is simply ensuring that the service uses the UserRepository to interface with the database. These methods are simply performing CRUD-like operations on the User objects which are just POJOs.

Now, we mentioned POJOs but how do they even represent the data we are using? Most of it is simply having a getter, setter, and maybe a few methods here to represent unique use cases of manipulating the data. An example of a User model associated with the above would look something like:

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String firstname;
    private String lastname;
    private String email;

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

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Now we see that we also have the @Entity annotation here, but not to worry, it is simply ensuring that this can be mapped to a table in a database - this lets use the JPA (Java Persistance API) as mentioned earlier! @Id is also included in this class to mark a primary key of the entity and this is just a unique identifier as the name implies.

The service class ensures that these POJOs transfer data between the repository and the controller, which we have not touched upon much, but essentially allows us to separate the presentation later from the application logic. Services are special in the sense that we can make sure the core logic of the application is applied properly before any data is saved, retrieved, or manipulated.

After going through all of this, it is crucial to understand how a typical Spring application flows together, and some key parts as mentioned are the controller (handling requests), service (business logic), and the repository (for CRUD operations). To leverage Java Spring’s full potential, these annotations are super useful to know and adapt, as they make the code more readable as well as maintainable!

Looking Ahead

In order to take full advantage of Spring and really understand what a brilliant architecture of an application may look like, it is vital to explore the microservices architecture, which I plan to delve into within the next article! Microservices are nice in that they offer more scalability and flexibility, since we can break down the application into smaller, deployable services.