Azure Logic Apps: A DevOps Project on Automated Document Processing System
Lesson 19. Introduction
Azure Logic Apps is a cloud-based, low-code workflow automation and integration service that lets you build and run automated workflows across cloud and on‑premises systems using prebuilt connectors and a visual designer. It supports more than 1,400 connectors, integrates with Azure services, Microsoft 365, SAP, and Salesforce, and can orchestrate AI agents for intelligent automation.
Uses Cases
● Automating Data Flow: Extracting data from one system, transforming it, and loading it into another system.
● Business Process Automation: Automating tasks like sending approvals or managing order workflows.
● Integrating Cloud and On-Premises: Bridging systems that run in different environments.
Tools
Microsoft Azure Portal • Azure SQL Database • Azure SQL Logical Server • Visual Studio Code • HTML/CSS/javaScript.
Lab
Project: Automated Document Processing System
Scenario: A company receives documents from different departments. When a document is uploaded to cloud storage, the system should automatically:
Detect the uploaded file
Process the file using serverless code
Extract or generate metadata
Send a notification email with the results
This entire process must run automatically without manual intervention.
Architecture
Steps
Create a Resource Group
> Log in to the Azure portal.
> Search for a resource group.
> Click Create
> Add Subscription: Your subscription (Azure subscription 1)
> Give the Resource Group Name: doc-processing-rg
> The Region should be the same region for all services (West US 3)
> Click Create.
This screenshot shows the creation of Resource group.
This screenshot shows that doc-processing-rg was successfully created as a resource group.
Create Azure Blob Storage
> In the Azure search bar, search for storage account and click Create.
> In the Resource Group field, select the newly created resource group. (doc-processing-rg)
> Set a unique storage account name (docprocessingstorage0808)
> Ensure the region is the same as the RG.
> In Primary service, select Azure Blob Storage or Azure Data Lake Storage
>In Performance, select Standard
> Redundancy: LRS
> Click Review and Create
> Click Create
The screenshot shows a green confirmation that the docprocessingstorage deployment is complete. The deployment is associated with the doc-processing-rg resource group, with an option to view the deployed resources.
Creating Blob Containers
> Click and open the resource
> Under the recently created resource group,
> Locate Data Storage
> Click on Containers
> Click on Add containers
> Give the container a name: uploads
> Ensure that the Access level is private.
> Click Create
The screenshots above explain the process involved in creating a container. Here, a container named uploads is created under the docprocessignstorage. The purpose of creating this container is to upload incoming files.
Creating the Function Locally
> Open VS Code
> Create a new Folder under the function folder called doc-processing. You can create this as a folder on its own.
The screenshots show the Windows folder-selection dialog in the LAB directory. Inside the Functions folder, the doc-processing folder is created, selected, and opened in VS Code. This establishes the project workspace where the doc-processing folder can be edited and tested.
> Click on Open Terminal and select New Terminal
> Run the command func init — This command is used to initialize a function.
> Select Node
> Select JavaScript
This screenshot shows the initialization of the function. The func init command was used, and afterwards Node was selected as the runtime, followed by JavaScript as the programming language.
> Run the command func new
> Select the HTTP trigger
> Give the function a name: ProcessDocument
This screenshot shows the successful creation of the function ProcessDocument using the HTTP trigger template. The func new command was run, and the HTTP template was selected.
Installing Azure Functions Library
> Run npm install @azure/functions
This screenshot shows that the npm install @azure/functions command was used to install the Azure Functions library. This is what Azure Functions depends on to work. The result shows the number of added and audited packages.
This screenshot explains the different parameters that were set to achieve the desired results. In the ProcessDocument.Js file, GET helps you fetch data, and POST helps you save data; other parameters like the const and its result, as well as what the code is to return, were set too.
Run the Function Locally
> Run the command func start
> Copy and run the URL displayed. It should look like this: ProcessDocument: [GET,POST] http://localhost:7071/api/ProcessDocument.
> This is expected to display a “missing filename parameter” error message.
The above screenshots explain the use of func start command to start the function. It started and initialized the worker process, with a result displaying the localhost URL. The URL is copied and loaded into the browser, which displays a missing filename parameter. This is because no parameter has been added.
Test the Function
> Run the command in your Browser to see the effect http://localhost:7071/api/ProcessDocument?fileName=report.pdf&fileSize=200
This simply shows the processed document. The function realizes that something was uploaded to blob storage; it checks the filename and file size, displays the processing time and date, and informs you if the document was processed successfully via the status.
Create Azure Function
> On Azure, search for and open the Function App
> Click Create
> Select Flex Consumption
> Select the same RG
> Give the function a name. Note: it must be unique (doc-processing-function)
> Region is the same as all. West US 3
> Runtime is Node.js
> Select Version as 22LTS
> Instance size 2048mb
> Disable zone redundancy. It is disabled by default.
> Click Next: Storage
> You can create a new storage account or select the existing storage account. Note: The existing one was selected.
> Click Review + create
> Click Create
> Click Go to Resource
The screenshot with a green confirmation shows that the Microsoft-web-Function-App-Portal deployment is complete. The deployment is associated with the doc-processing-rg resource group, with an option to view the deployed resources.
Get Emele Chijioke’s stories in your inbox
Join Medium for free to get updates from this writer.
Publish the function.
> In your VS Code, run the command: func azure functionapp publish <azureFunctionAppName>
This screenshot shows the use of the command func azure functionapp publish <azureFunctionAppName> to publish the function app that we created. It provides you with the function URL. This is to display the missing error parameter when accessed through a browser.
Alternatively,
> Open the Function App portal
> Open the ProcceDocument
> Under Code + Test, click on Get function URL
> Copy any of the URLs
This is a screenshot displaying the missing Filename parameter error when accessed through a browser
Create the Logic App
> In Azure, search Logic App.
> Right-click and open link in a new tab.
> Click Create
> Select Multi-tenant
> Select the same RG
> Give the Logic App a name — Name: document-processing-logicapp
> Select the same Region — WestUS 3
> Leave other settings.
> Click Review + create
> Click Create
Adding a Trigger
> Click on Go to Resource
> Click on Development tool
> Select Logic App design
> Continuing from Logic App Design
> Click Add a trigger.
> Search Blob storage ie, Azure Blob Storage
> Give the connection a name or leave it as it is. Name: blob-connection
> Authentication Type: Access Key
> Azure storage account name: The name of your storage account, i.e docprocessingstorage0808
> Enter Azure storage account access key. To get this,
> Go to the storage account
> Locate security + Network
> Click on Access Key and select one of the keys.
> On the trigger dialog box, click Create New.
Trigger / Service Configuration
> Under storage account name or blob endpoint, select: Use connection setting (login app name).
> Under container, select uploads
> Leave other default settings.
> Select the number of blobs as 1
> Frequency: Every 1 Minute
> Select the time zone of your choice if necessary
> Click Save.
Call the Azure Function
> Click on the small circle with a plus sign and select Add an Action.
> Select HTTP twice
> Under URL, copy and paste the function app URL. ie ProcessDocumentFunction URL. This can be gotten from Function App > doc-processing-function> ProcessDocument> Get function URL.
> Under Method, select POST.
> Set up the body with this
{
“fileName”: “@{triggerOutputs()?[‘body/Name’]}”,
“fileSize”: “@{triggerOutputs()?[‘body/ContentLength’]}”
}
> Click Save.> Select HTTP twice
> Under URL, copy and paste the function app URL. ie ProcessDocumentFunction URL. This can be gotten from Function App > doc-processing-function> ProcessDocument> Get function URL.
> Under Method, select POST.
> Set up the body with this
{
“fileName”: “@{triggerOutputs()?[‘body/Name’]}”,
“fileSize”: “@{triggerOutputs()?[‘body/ContentLength’]}”
}
> Click Save.
Send an Email Notification.
> Under the HTTP action, click the plus connector sign
> Select Add an action
> Search for send an email and select Outlook or Gmail. I used Outlook.
> Select Send an email (v2)
> Click Sign in for free flow of the automation and select your Gmail or email with your Azure account.
> Under the TO in the parameter section, type in emails that would be used for the automation.
> Type in the subject of the email notification of your choice: Document Processed Successfully.
> Under the body section, type:
A document has been processed.
File Name: @{triggerOutputs()?[‘body/Name’]}
File Size: @{triggerOutputs()?[‘body/ContentLength’]}
The document is in the Uploads folder.
> Click Save and Run.
Testing the System
> Open the storage account created (docprocessingstorage0808)
> Click Data Storage and click on containers
> Select uploads and upload a file (pdf)
> Click Upload file.
> Wait two minutes for automation to be created.
> In your Gmail or any other email that was specified, check for the automated email response as confirmation.
Confirmations
The above email screenshots show the email alert confirmation that the automation is functioning.
CONNECT TO GITHUB
> Log in to your GitHub account.
> Create a new repository
> Give your repository a name (logic-app)
> Give a description — This is optional
> Choose visibility to be public or private
> Click on Create Repository
> git init
> Type git remote add origin https://github.com/EmeleCj/logic-app.git — Connect your GitHub repo to the exact one you have locally.
git status
git init
git add .
git status
git remote add origin https://github.com/EmeleCj/logic-app.git
Here, the terminal initializes a new Git repository in the Functions folder, stages all files from the doc-processing and my-first-function Azure Function projects, and adds the remote origin pointing to the logic-app GitHub repository.
> Run the command git commit -m “First commit”
> Run the command git push origin master — We are pushing to the master branch.
git commit -m "First commit"
git push origin master
Here, the terminal successfully creates the first commit with 14 files and pushes the master branch to https://github.com/EmeleCj/logic-app.git.
The GitHub repository page for EmeleCj/logic-app displays the successfully pushed doc-processing and my-first-function folders from the first commit, along with the project description “Azure Logic App.
Clean Up.
For a learning lab, keep an eye on your Azure budget and delete resources when you finish testing. Note. The created Resource Group was deleted after the practical work.
Challenge and Resolution
Conclusion
The Automated Document Processing System establishes a fully automated, event-driven workflow designed to eliminate manual overhead in document handling across departments. By combining cloud storage triggers, serverless compute, and automated messaging, the system creates a streamlined pipeline for immediate file detection, custom metadata extraction, and notification dispatching.
Thank you
#LearnWithCeejay!
