DEV Community: Akhil Varma

Automating GDPR Data Deletion Requests with Appsmith Workflows and Human-In-The-Loop Approvals

Akhil Varma — Fri, 25 Oct 2024 14:43:41 +0000

Handling General Data Protection Regulation (GDPR) data deletion requests can be challenging, especially when user data spans across multiple systems. Low-code workflow automation offers a solution to this complex problem. At Appsmith, we store user data in several places: an internal MongoDB, a Segment warehouse (Postgres), Mixpanel for analytics, and Mailmodo for email campaigns.

To ensure compliance with GDPR and streamline this process, we implemented an automated workflow using Appsmith, a low-code workflow automation solution. This solution integrates a Human-in-the-Loop (HITL) approval step to ensure oversight before deletion.

Before diving into the solution, it's crucial to understand what GDPR compliance entails and why it's important.

What is GDPR compliance and why does it matter?

The GDPR is a data protection law that came into effect in the European Union in 2018. It gives individuals greater control over their personal data and imposes strict rules on those hosting and processing this data, anywhere in the world.

GDPR compliance is crucial for several reasons:

Legal requirement: companies handling EU citizens' data must comply or face severe penalties.
Consumer trust: demonstrating strong data protection practices enhances customer confidence.
Reputation management: non-compliance can lead to negative publicity and loss of business.
Global standard: GDPR has influenced data protection laws worldwide, making compliance a global best practice.

GDPR's "right to be forgotten" can present significant challenges for businesses

One key aspect of GDPR is the "right to be forgotten." This provision allows individuals to request the deletion of their personal data, presenting a significant challenge for businesses.

Companies dealing with this rule face many challenges, especially when they have to manage data spread across different systems while following strict rules. This creates a complicated situation for businesses to handle.

Here are a few challenges businesses may face in complying with GDPR data deletion requests:

Data spread across platforms: User data is often stored in multiple systems owned by different teams (tech, product, marketing), making it difficult to ensure complete deletion across all locations.
Penalties for non-compliance: GDPR violations can lead to fines of up to 4% of global revenue or €20 million, along with reputational damage and legal risks.
Efficient request handling: Delays or errors in processing deletion requests can result in customer dissatisfaction and legal disputes.
Internal data security: Sensitive data in internal databases poses a challenge when using external tools, as whitelisting external IPs can introduce security risks.
Controlled automation: Businesses need automated processes with oversight, ensuring compliance while protecting internal systems.
Audit trail requirement: Maintaining a detailed log of deletion actions is essential for compliance, making automation crucial for error-free record-keeping.

A self-hosted low-code workflow automation solution like Appsmith helps automate and manage data deletion requests, allowing you to securely and efficiently address these challenges while maintaining full control over your processes.

Automate GDPR data deletion requests using Appsmith's low-code workflow automation incorporating HITL approval

We developed a low-code workflow that automates the data deletion process while incorporating a human-in-the-loop (HITL) approval step. HITL refers to a process where human judgment is integrated into an automated system, allowing for oversight and decision-making at critical points.

This approach ensures that a human reviewer can verify and approve data deletion requests before execution, adding an extra layer of security and compliance to the automated workflow.

Here's an example of how to implement the data deletion process using Appsmith's low-code workflow automation along with other tools, including Front, MongoDB, Segment (Postgres), Mixpanel, and Mailmodo.

Step 1: Initiating the data deletion request

Users can raise a ticket through any channel—email, chat, or other support mediums. Front, our aggregation tool, captures these requests. Once a ticket is created in Front, it automatically triggers the low-code workflow. Appsmith AI then analyzes the ticket content to determine whether it contains a data deletion request.

If Appsmith AI identifies a deletion request, it promptly notifies the user, acknowledging receipt. This immediate confirmation reassures the customer that their request is being processed.

Step 2: Human-in-the-loop approval

After identification, the low-code workflow doesn't immediately proceed with data deletion. Instead, it routes the request for HITL approval, where one of our senior customer support managers reviews it for accuracy and legitimacy. The workflow only moves forward after approval, ensuring careful oversight while leveraging automation's efficiency.

Step 3: Data deletion across systems

Once approved, the low-code workflow automatically deletes the user's data from all relevant systems:

Internal MongoDB: Removes personal details, interaction logs, and audit log information.
Segment Warehouse (Postgres): Deletes and suppresses user data to prevent future collection.
Mixpanel: Fully removes the user profile, erasing all engagement and analytics data.
Mailmodo: Archives the user's contact to prevent future use in marketing campaigns.

Appsmith automatically retries if minor issues occur, such as temporary connection failures, ensuring the deletion process completes without manual intervention.

Since some user data resides in our internal infrastructure, Appsmith's self-hosted capability allows us to securely access this data without exposing our systems to external SaaS tools via IP whitelisting. This gives us complete control over sensitive internal operations.

Step 4: Logging and auditing

The workflow maintains an automatic log of every action throughout the process, including timestamps, systems involved, and any errors encountered. This audit trail is critical for GDPR compliance, providing transparency and allowing us to demonstrate proper handling of data deletion requests.

Step 5: Notifying the user

Once the data deletion process is complete, the user receives an automatic notification confirming successful deletion. This final communication, combined with the initial acknowledgment, ensures clear communication throughout the customer journey.

By leveraging low-code workflow automation with Appsmith, including AI and HITL approval, companies can streamline data deletion requests, ensuring GDPR compliance while maintaining full control over sensitive internal systems. Automated notifications and audit logs provide a transparent and secure process for both customers and regulatory needs.

Why choose Appsmith workflows?

Appsmith is an open-source, low-code platform that enables developers to build custom applications and automate workflows quickly and efficiently.

The key advantage of using low-code workflow automation with Appsmith is the flexibility and control provided by its self-hosting capability. In our case, some of the user data resides in internal databases, and we didn't want to expose these systems by whitelisting IP addresses for SaaS tools.

Appsmith's low-code approach allowed us to automate the process securely, without compromising the integrity of our infrastructure.

Get started with low-code workflow automation for GDPR data deletion requests

As businesses continue to seek ways to optimize their operations, Appsmith's low-code workflow automation stands out as a flexible, scalable, and cost-effective solution for optimizing business operations, particularly in complex compliance scenarios like GDPR data deletion. Getting started is straightforward—explore Workflows in our cloud sandbox or sign up for the beta to self-host.

Streamline Procurement Approvals with Low-Code Workflow Automation

Akhil Varma — Mon, 30 Sep 2024 09:44:43 +0000

Businesses must consider numerous factors to grow effectively over time. Streamlining critical processes like procurement approvals can significantly enhance operational effectiveness.

This article explores how low-code automation, specifically using Appsmith Workflows, can help developers transform the procurement approval process, making it faster, more transparent, and less error-prone for businesses.

Why automate processes with low-code?

Low-code automation tools have gained traction in recent years, offering businesses a way to optimize their operations without the complex development burden.

These tools reduce development time, lower the long-term cost of ownership, and simplify the implementation of business logic compared to writing boilerplate code. They offer several key advantages:

Rapid development: Low-code tools enable quick building and deployment of automated workflows in a fraction of the time compared to building from scratch.
Flexibility: Every business is unique, and your automation should reflect that. Low-code platforms can be easily customized to fit specific business needs and processes, especially when they allow for adding custom code.
Integration capabilities: Your tools need to communicate with each other. Low-code developer-centered solutions come with built-in integrations for existing systems or through REST/GraphQL APIs.
Reduced technical debt: With less custom code to maintain, the long-term cost of ownership is lower.

Low-code automation offers a way to quickly implement solutions that would otherwise require significant time and resources to build from scratch.

While traditional development might involve months of work and a team of skilled developers to automate processes, low-code platforms can dramatically reduce this timeline and complexity.

The procurement predicament: when manual becomes a maze

In many organizations, getting approval for a purchase can feel like navigating a labyrinth blindfolded, as it often involves complex multi-level processes with numerous stakeholders.

A typical procurement request might go through multiple stages of review and approval—from initial submission to endorsements by managers, department heads, and senior executives before receiving final approval.

Managing these stages manually or using disparate systems leads to inefficiencies, delays, and communication breakdowns.

Some common issues include:

Lack of visibility into the current status of requests
Delays caused by manual routing and communication
Over-reliance on emails for notifications and updates
Difficulty tracking approvals, leading to bottlenecks

These challenges not only slow down the procurement process but can also lead to missed opportunities, increased costs, and frustrated employees. A centralized, automated solution is needed to address these challenges effectively.

Automate procurement approvals with low-code automation using Appsmith workflows

Appsmith is an open-source low-code platform designed for building internal tools and automating business processes. It offers a powerful solution for creating custom applications and workflows without extensive coding.

We recently introduced the feature workflows, which provides an efficient way to manage and automate the entire procurement approval process in your business. Here's how Appsmith workflows addresses key pain points in the procurement process:

Centralized workflow management: Appsmith allows all stages of the procurement process—from submission to final approval—to be managed by one workflow. The workflow automatically routes requests based on predefined rules such as approval amounts, department hierarchies, and user roles, ensuring the right stakeholders are notified at each stage. This centralization eliminates the need for manual handoffs and reduces the chance of requests getting lost in the system.
Automated notifications and status tracking: Instead of relying on manual emails, the workflow sends automatic notifications when a status changes, whether it's a submission awaiting review or an endorsement pending approval. Stakeholders are promptly notified based on predefined triggers, reducing communication delays. This ensures that all parties involved are always aware of the current status of a request, improving transparency and reducing follow-up inquiries.
Dynamic forms and configurations: The workflow adapts to user needs, allowing input of relevant data—such as service types and supplier details—through searchable and filterable dropdown menus. This streamlines form submissions, minimizes errors, and speeds up the overall process. Forms can be easily updated to reflect changes in the procurement process without extensive recoding. Appsmith allows building a UI that captures request information and inputs necessary data for subsequent steps.
Smart routing logic: Based on factors like request amounts and department structures, the workflow automatically determines the correct approval path. This logic ensures compliance while minimizing manual intervention and decision-making delays. It also allows for easy implementation of complex approval hierarchies that might be difficult to manage manually.
Flexible options for procurement teams: In cases where the procurement team initiates the request, the workflow allows them to input necessary data upfront and skip steps that don't apply, ensuring the process remains efficient. This flexibility accommodates various scenarios and user roles within the procurement process, making the system adaptable to different organizational structures.

Here's an example illustrating the key automated steps of procurement approvals using Appsmith workflows:

Dynamic form submission for initiating requests
Smart routing logic based on predefined rules (e.g., approval amounts, department hierarchies)
Multiple approval levels with automated routing
Automated notifications at each stage of the process
Real-time status updates in the system

This automated workflow centralizes the entire process, reduces manual interventions, and ensures transparency throughout the procurement approval cycle.

Discover how with Appsmith workflows and AI you can automate feedback analysis, ensuring a more responsive and proactive approach to customer needs.

How can your tech team benefit from Appsmith low-code automation for procurement approvals?

Appsmith workflows offers a developer-focused platform that can significantly improve your tech team's ability to automate complex business processes. Among the key benefits are:

Rapid development: Combines code-based and node-based systems for faster workflow creation, allowing developers to focus on logic and functionality rather than tedious configurations.
Flexibility and customization: Incorporates complex logic through JavaScript, allowing your team to tailor the procurement approval process to your organization's specific needs and requirements.
Seamless integrations: Easily connects with existing databases, making it simpler for your tech team to integrate with existing databases, ERPs, or other internal tools.
Human-in-the-Loop capabilities: Allows your team to build workflows that seamlessly incorporate human decision-making when necessary, ensuring compliance and maintaining control over critical approvals.

Using Appsmith workflows, your tech team can streamline the development of procurement approval systems, saving time and resources while allowing your developers to focus on strategic initiatives—all while delivering robust, scalable, and customized automation solutions for your organization.

Low-code automation vs. manual processes

While smaller businesses often find it easier to manage procurement approvals manually, this approach doesn't scale well as the company grows. Even for small businesses, developers should anticipate how manual processes can become problematic over time.

Implementing low-code automation early on provides a quick and easier path to ensure these processes can scale effectively as the business expands. Here are the benefits of low-code automation compared to manual processes:

Aspect	Manual process	Low-code automation
Speed	Slow, time-consuming	Significantly faster processing times
Accuracy	Prone to human errors	Minimized errors due to reduced manual data entry
Consistency	Varies based on individual handling	Consistent approval paths for all requests
Visibility	Limited, often unclear status	Real-time access to request status
Scalability	Difficult to scale efficiently	Easily handles increased volume without proportional resource increase
Cost-Efficiency	Higher long-term costs	Initial investment, but long-term savings in time and resources

The shift from manual to automated processes can be transformative, freeing up resources to focus on strategic initiatives rather than administrative tasks.

Get started streamlining procurement approvals

As businesses continue to seek ways to optimize their operations, low-code automation stands out as a flexible, scalable, and cost-effective solution for optimizing business operations.

Get started to speed up the development process and reduce the long-term maintenance burden.

Automate complex, human in the loop processes

Try Appsmith’s new workflow features in public beta. Build secure automated processes with streamlined integrations and code-first controls.

Automating Customer Feedback Analysis with Appsmith, Fathom, Slack, and AI

Akhil Varma — Tue, 03 Sep 2024 08:28:43 +0000

Analyzing customer feedback is vital for product improvement and business growth. It provides insights into user needs, pain points, and preferences, enabling businesses to make informed decisions. However, gathering and processing feedback from various sources like surveys, social media, and customer calls can take time and effort to scale effectively.

At Appsmith, we faced the same challenge. To address this, we've developed an innovative AI-driven workflow to streamline how we process and analyze customer insights. This article will explore our approach to automating customer feedback analysis, which helps our product team make data-driven decisions quickly and efficiently.

The challenge of efficiently extracting valuable customer insights from numerous sources

As a rapidly growing company, Appsmith's customer-facing teams engage in numerous weekly video calls with clients. These interactions are goldmines of information, offering deep insights into customer needs, pain points, and desires. However, the sheer volume of these calls presented a significant challenge: how could our product teams efficiently extract and act upon these valuable insights without spending countless hours reviewing call transcripts?

This challenge is not unique to Appsmith. Many companies need help with effectively analyzing and implementing customer feedback at scale. Traditional methods of manually reviewing call transcripts or survey responses are time-consuming and often lead to delays in product improvements, which can be costly in a competitive market.

AI-powered workflows to automate customer feedback analysis

Appsmith is a low-code platform that allows developers to quickly build custom internal tools and applications. It offers many features, including creating complex workflows and integrating AI capabilities.

One of Appsmith's key features is its Workflows functionality. Workflows in Appsmith help automate critical business processes based on predefined rules and enable Human-in-the-Loop (HITL) interactions.

That is why we built a solution that is not only AI-powered but also leverages Appsmith workflows to streamline our customer feedback analysis process. This application analyzes call transcripts and automatically generates actionable insights, simplifying the process for our product teams. This AI-driven approach saves time and ensures that valuable insight is noticed, significantly improving our ability to respond to customer needs.

Here's a detailed look at how it works:

Automated transcript analysis: The workflow begins using Appsmith AI to analyze transcripts generated by Fathom, our call recording tool. The AI identifies key actions and pain points customers express during these calls.
Intelligent feature mapping: Once the AI identifies action points from the transcript, it maps them to specific features mentioned during the call. This crucial step ensures the feedback is directly relevant to our product roadmap and ongoing development efforts.
Team assignment: The system then automatically associates the identified features with the relevant teams within Appsmith. This intelligent assignment ensures that insights are directed to the right experts who can act on the feedback.
Automated Slack notifications: A concise summary of the insights is generated and sent as a Slack message to the respective teams, ensuring everyone stays in the loop without being overwhelmed by unnecessary details.
Seamless integration: One of the key strengths of this workflow is its integration within the Appsmith ecosystem. The entire process is done through native Appsmith integrations, meaning our teams don't have to switch between multiple platforms or learn new tools.

This AI-driven workflow leverages Appsmith's robust integration capabilities. These allow us to connect seamlessly with tools like Fathom for transcript generation and Slack for communication.

Automating customer feedback analysis compared to manual analysis

In the long run, automating customer feedback analysis through an AI-powered workflow is the best way to understand your customers' needs better and act on them. An AI-powered workflow offers several advantages over traditional manual methods:

Aspect	AI-powered workflow	Manual analysis
Time efficiency	Processes large volumes of data quickly, freeing up valuable time for product and customer-facing teams to focus on strategic tasks.	Time-consuming, requiring extensive hours to review and analyze feedback data.
Accuracy	Reduces human error and bias, providing consistent and objective insights.	Susceptible to human error and subjective interpretations.
Scalability	Handles increased data loads effortlessly as the company grows.	Struggles to keep up with growing data volume, requiring more resources.
Response time	Delivers insights promptly, enabling quicker reactions to customer needs.	Lengthy analysis periods which can lead to delayed responses.
Data-driven decisions	Generates continuous streams of actionable insights for informed decision-making.	May miss key insights due to data overload and manual filtering constraints.

Implementing this AI-driven workflow can uncover persistent customer recurring pain points that manual reviews might miss. Furthermore, identify emerging trends in customer requests that aren't yet part of your roadmap. This early detection allows your product team to reprioritize and accelerate the development of these requests, ensuring a more responsive and proactive approach to customer needs.

Get started with Appsmith and enable your product team to focus on delivering features that meet your customer's needs

This AI-driven workflow perfectly exemplifies how automation and AI can simplify complex, time-consuming tasks. By automatically generating and delivering customer insights, our product teams can focus on what truly matters: building features that solve real customer problems.

You can experience the benefits of Appsmith Workflows firsthand. Get started with your AI-driven customer feedback analysis by following these steps:

Sign up to Appsmith Business Edition and access the Appsmith workflows beta.
Use our custom ChatGPT to help you set up and optimize your workflows.

If you have any questions, don’t hesitate to contact us at akhil@appsmith.com.

Git in Appsmith: A Practical Guide for Building Internal Apps with Git

Akhil Varma — Mon, 20 Nov 2023 18:16:43 +0000

This guide explains the Git best practices that you should adopt when building internal apps — for better collaboration, app quality, and reliability.

So far in our Git announcement series, we've discussed why Git is so important for developers and how proud we are of our “first to the moon” moment on getting the first real, fully-functional Git implementation for a web-based apps platform. To conclude, this article shows you how you can use Git to improve your workflows, enable easier collaboration, and improve the quality and reliability of your Appsmith apps.

General Git best practices for collaboration, iteration, and reliability

Git is a flexible tool that can be adapted to pretty much any workflow, but there are better and worse ways to use it. We designed Appsmith's Git functionality around the best practices of experienced developers, making Appsmith a great place for beginners to build good habits.

If you’re new to Git, we recommend that as a first step you check out the official Git quickstart videos and the official Git glossary to get acquainted with all of the terminology before you begin. Otherwise the upcoming talk about commits, branches, pushing and pulling, and even forking might get a bit confusing.

Now that you're familiar with Git terminology, let’s talk about some of the best practices for using Git whether you’re using Appsmith or not:

Never commit directly to the main branch

The main branch of your codebase should be reserved for code you consider ready to ship. Code should go through the full process of ideation, planning, implementation, testing, and more testing before being merged to the main branch.

Use feature branches to implement new functionality

If you’re working on a new feature or making improvements to an existing one, you should create a branch where you can work on that change in isolation. Then, when you're done, you can test that it works in your development environment, and then test it against other changes that may have been made in other branches since you began, and finally merge it into the main branch once you've confirmed nothing has broken. This is called using feature branches.

Commit incremental changes

Split the changes and additions you need to make to your code down into standalone pieces as much as possible and commit them individually. Then, if there's a problem with one of the changes, you can roll it back and fix it on its own, rather than having to roll back ALL of the changes you've made. It also makes merging back into the main branch easier — small changes are easier to troubleshoot if merge conflicts do occur.

Think of using separate feature branches and committing incremental changes a bit like baking a cake — you can crack the eggs directly into the main mixture and risk a bad egg ruining the whole recipe, or you can crack the eggs into a separate cup to examine them before mixing them in.

Push your code to a remote repository often

Git is a distributed version control system, so it can sync your code between multiple remote machines or online repositories hosted on services like GitHub and BitBucket. This is great for collaboration and it's also a very convenient way to make sure that your valuable code is backed up offsite.

Disasters can and will cause unexpected data loss. Fire, theft, faulty storage devices... There are innumerable ways for your data or the devices storing it to be damaged or destroyed, and your team will not be happy with you if you’ve failed to push your code.

Be verbose

Explain the changes you've made and why you've made them. Even seemingly trivial changes should be documented with comments and in the commit message, to establish good habits and ensure that all changes are visible and understood for code review. Your solution to a difficult problem may not be obvious to others.

If you're a solo developer, verbose comments and commit messages will still pay off in the long term — your memory is not as good as you think it is, and “future you” may not remember exactly how or why “present you” implemented a particularly nifty code hack.

Perform code reviews

You have separate branches with incrementally committed changes that are well described with comments and commit messages. Congratulations! You just made reviewing that much more straightforward.

Just knowing that someone else is going to read your code leads to a marked improvement in code quality and commenting — we think it's just the subconscious result of developers wanting to help their colleagues out during review. Routine code reviews mean that senior devs can also be more confident in the work junior devs are producing, while junior devs can also learn from senior devs and gain confidence.

Ensuring that code is reviewed prior to merging into the main or production branches also helps to make sure that no show-stopping bugs or security vulnerabilities make it through to your users.

Choose a branching strategy that works for your project and organization structure

Git largely leaves it up to you to use it how you want, but through planning and experience (also known as trial and error), several recognized key strategies have emerged to make the most of Git’s features.

You should avoid straying too far from convention when choosing your strategy and make adaptations only if necessary. You want your branching strategy to make sense to others and be adoptable by other teams that may join your project.

Be conflict-averse

Merge conflicts are usually caused by different developers working on the same code in the same file on separate branches and then trying to merge them. Git is not an intelligent system: it just does what you tell it to do, so it has no way of knowing which is the “correct” change to keep.

It's your job to identify the cause of the conflict and determine which change to carry forward. Merge conflicts can be greatly reduced by keeping your code organized, giving team members ownership over separate features or parts of the codebase, and encouraging them to consult with the person responsible for another section if they need to make changes there.

Best practices for Git in Appsmith

Appsmith's goal is to make app development as quick and easy as possible, and that extends to our Git implementation. We'd like to highlight a few features that assist you and some additional strategies that you should adopt to get the most out of Git on our platform.

Storing secrets

“Secrets” are the credentials you use to access database, API, communication, and other services when developing and deploying your software. They must be kept secret for a reason — database and API credentials can be used to access and modify data intended to be kept private and, in the case of APIs for paid services, cost you money if somebody else gains access and decides to run up your bill.

In Appsmith, we automatically redact all credentials used to access configured datasources. They'll never enter version control if you use the in-built functionality for storing those credentials.

If you have other kinds of secrets that you would like to avoid committing to version control, you should ensure that they are retrieved from a secure location when your app is run so that they are not present in your code.

Using branches and integrating Git workflow techniques

Your branching strategy can be extended to use development, staging, and production branches instead of a single main branch. These Git workflow best practices allow you to test changes prior to deploying them, improving the reliability of your deployed applications.

This is also useful if you are self-hosting Appsmith and want to stick with an older platform version in production while you test that your apps are compatible with an updated release. You can create a new branch, fire up a Docker container running the latest version of Appsmith, and test and tweak it without affecting your production deployment.

Be extra verbose

It's helpful to be extra verbose when writing your Git commit messages: note what you've changed, why you've changed it, and any potential repercussions for other developers (or your future self).

Providing as much detail as possible in these messages is important in Appsmith because we let you build apps in a drag-and-drop graphical interface. These interfaces are then converted into text files that may not make it obvious exactly what has changed, especially since users can’t directly write comments in the source files.

Don't forget how Git works

Every Git action in Appsmith is performed with the click of a button instead of by entering commands on the command line. One click will often perform multiple actions in a Git workflow that would otherwise take several commands.

A manual Git workflow for creating a new branch requires running the following commands to perform various actions:

git pull to fetch the latest code from the remote repository
git checkout -b new-branch-name to create a new branch and check out
git status to confirm the current status of the branch
git diff to see any pending changes
git add to add files
git commit to commit the current changes to the local repository
git push to sync the changes in the local repository to the remote repository

When using Git in Appsmith, this workflow is performed by:

Clicking the button to pull the latest version of your app from the remote repository
Clicking the button to create a branch
Making changes to your app
Clicking the button to commit. Changes won't sync to the remote repository until you commit, and git push happens automatically after a commit.

It's worth making sure you’re familiar with how Git works before you start using these streamlined functions, just so you know what's going on in the background. If you do manage to get your application into a bad state with merge conflicts, knowing how Git functions will let you work your way back out of it.

How to use Git in Appsmith

Appsmith connects to Git repositories through standard SSH key-based authentication (supported by GitHub, GitLab, BitBucket, and other managed and self-hosted options) so that you are free to choose your own Git provider.

You can start with a blank repository for new apps, or you can pull from an existing repository to work on an existing Appsmith application.

We’ve made Git as convenient as possible in Appsmith. You can see what branch you are on in the bottom left corner of the screen (no more typing git status all the time to remember where you are!). If you want to switch to or create a branch, you can manage your remote and local branches without worrying about adding the right flag to your git branch or git checkout commands.

Committing code works just as you’d expect — you can see which pages and files in your application changed.

We’re working on improving our git diff functionality so that you can see the changes to the individual lines in the files we’re generating from the Appsmith database, which will further enhance the code review process for our users.

You can also easily merge the changes from one branch into another.

Alt-text: .

All the operations that a developer needs in their workflow are now implemented, and we’re continuing to work on additional functionality to take our Git feature to the next level and automate even more of your app development workflow.

A simple Git workflow for small development teams and projects

Git is pivotal for the operation of large development teams, but it's also a life-saver for small development teams and solo developers. By ensuring that it's easy to roll back changes and back up your work so that it is never lost, it allows for risk-free innovation and iteration.

A simple Git workflow that you can adopt for your Appsmith projects when working in a small team. This is based on GitFlow.

Extending your Git workflow

If you're working in a larger team, you can integrate bespoke branching strategies into your Git workflow to improve collaboration based on your requirements. If your app relies on other back-end services that you develop, you can also coordinate updates to deploy at the same time across your infrastructure, so nothing breaks.

You can also look into other workflow architectures, such as trunk-based development. This can streamline development in larger teams by fully relying on the features of modern version control and rapidly deploying changes rather than waiting for everyone committing to a development branch. There are risks to the stability of your application compared to the GitFlow workflow, but teams with rigorous code review and robust CI/CD practices often see delivery time and other benefits from it.

Start building with Git and Appsmith in the cloud or on your own infrastructure

Git is fully supported in our free cloud-hosted version of Appsmith that lets you start creating your own apps with no installation and no infrastructure — just connect your GitHub repository, bring your data, and start building in your browser. Git is also fully supported in our self-hosted and enterprise versions for users and organizations with additional requirements.