Best Practices - Recent Threads

Safely removing unused columns identified via dependency checks in Appian

udhay kumar — Tue, 05 May 2026 16:34:59 GMT

Hello all,

I have come across certain columns of different tables which are not being used in anyway. To validate this, I have done the following :

Check for CDT dependencies Check for record type dependencies Search for usage of the field/column globally in the application

Based on the above, it appears that these fields are not being referenced by anything.

But prior to deleting the columns, I wanted to get your feedback regarding the following:

Does the above process ensure that the columns can be deleted without causing any issues ? Is there anything else that needs to be checked prior to deleting such columns (Process Models, integration etc.) ? What is the best way to delete such columns in Appian ? Am I supposed to deprecate these columns prior to their deletion ?

Thanks

State in appian

elvisb958752 — Tue, 05 May 2026 12:13:01 GMT

Is there any way in Appian to capture the previous state?
I have a form with a couple of dop downs where the user selects different assignees for different tasks
I want to able to send an email only to the changed users.
Is there any way to compare old user values with new ones to see if changes happen?

pessimistic locking

MM — Thu, 23 Apr 2026 12:07:30 GMT

I am considering implementing pessimistic locking in Appian.
However, I have heard that pessimistic locking can potentially degrade performance because it restricts concurrency.

In practice, how much impact does pessimistic locking typically have on performance?
Also, from a best practice perspective in Appian, what kind of design or implementation approaches should be considered?

Specifically, I would appreciate guidance on topics such as:

In which scenarios does pessimistic locking have a significant performance impact?
When should pessimistic locking be used, and when should it be avoided?
If pessimistic locking is required, are there any design techniques or best practices to minimize its performance impact?

Nested CDT takes too long to query data

Linh — Tue, 14 Apr 2026 09:10:42 GMT

Hi everyone,

I'm having a multi layer nested CDT (Nested CDT that is a column in another nested CDT column of the main CDT that uses as data type) which is taking too long to query data and sometimes causes time out error. I would love to have some suggestion to optimise/ replace it with something else if possible.

Thank you

I’m working on a large and complex process where we do not use User Input Tasks. Instead, we implemented a pool-based approach, where each group has its own pool of requests.

Omar Muthanna — Sat, 14 Mar 2026 18:31:24 GMT

Hi everyone,

I’m working on a large and complex process where we are not using User Input Tasks. Instead, we implemented a pool-based approach, where each group has its own pool of requests.

All request data is stored in the database. We also have an Admin Configuration interface that allows the admin to enable or disable certain tasks for specific groups.

For example, in the database we store a boolean flag:

true → the request/task should appear in the pool
false → the request/task should no longer appear

On the interface side, we are using a grid that queries the database and filters the tasks based on this flag to display the pool for each group.

The issue we are facing is the following:

When the admin disables a task (changing the flag from true to false), the request still appears in the pool grid. It only disappears after performing a hard browser refresh. The standard refresh mechanisms in the interface do not update the grid immediately.

My questions are:

Is there a recommended way to force the grid/pool to refresh immediately when the admin disables the task?
Are there any best practices for implementing pool-based task management like this in Appian?
Is there a better architectural approach for handling this scenario?

Any suggestions or best practices would be greatly appreciated.

Thanks!

I want to create custom Hub for my 4 applications where user can create request, view the request, work on assigned tasks , how can i do , please suggest me the possible approach

vedantd425564 — Fri, 13 Feb 2026 07:52:19 GMT

I want to create custom Hub for my 4 applications where user can create request, view the request, work on assigned tasks , how can i do , please suggest me the possible approach

Email handling as apps grow – how are you structuring it?

Arunkumar Arumugam — Mon, 09 Feb 2026 04:14:49 GMT

In one of our production apps, we currently send emails directly from the main process models using the Send Email smart service.

As volume is increasing, we’re starting to rethink whether this is the best long-term approach.

For those who’ve worked on larger implementations — do you keep email logic in the main process, or move it to a reusable subprocess? Also curious how you’re handling retries and basic monitoring in production.

Just trying to sense-check our design as the app scales.

Just wondering if anybody using lightspeed DEVOPS CI/CD pipeline with Appian

pramodk0005 — Thu, 05 Feb 2026 16:57:19 GMT

Hi everyone,

I'm curious to know if anybody using Lightspeed Devops CI/CD pipeline with Appian.

if so what's your take on it.

Thank you

How to optimize Multiple integration calls in one process model

sureshs276515 — Wed, 17 Dec 2025 13:45:58 GMT

Hi ,

have 6 integrations in the process model flow , it should be run in sequence manner and each integration is depending on previous integration call, now i have to complete the process model within 5 see , could you please let me best approach to follow ?

thanks!

Which option should I choose for a new application: Data Store, Process Data Persistence (PDP), Record Sync (RS), or Database-backed Record Types?

iswaryan3520 — Wed, 10 Dec 2025 07:20:26 GMT

Hi everyone,

I’m starting a new application in Appian and I want to choose the right approach for storing and managing data. Should I go for

Data Store (CDT + Data Store mappings) from there creating record type

Directly use the Record Type backed by a database table

What's the purpose of data store generally? I meant by for the modern Appian developement do we need data store necessarily

Since this is a new build, I want to follow best practices and avoid making architectural mistakes early.

My Question

For a fresh application, what is the recommended approach for:

Application/master/transactional data

CRUD operations

Reporting and relationships

Security and scalability

Long-term maintainability

Should I rely on Data Store, PDP, Record Sync, or directly use a Database-backed Record Type?

If you have any guidelines, comparison points, or real-world experience on which option is better in 2025 Appian architecture, please share your insights. Notes : Appian version is 24.2 .

Thanks!

which tool is better to use for testing with appian application

sureshs276515 — Tue, 18 Nov 2025 10:12:05 GMT

Hi Team,

which tool is better to use for testing with appian application for automation testing?

thanks!

Appian Direct Deploy Rollback - Best Practices

maximoferarenas — Fri, 17 Oct 2025 13:24:17 GMT

Hi. We need more precise information regarding advice and best practices for doing a rollback / reverting a direct deploy. We intend to do a big deploy which restructures a lot of tables, processes, rule expressions and interfaces. We want to have a rollback plan if anything goes wrong, but i dont find any option in the deploy panel for rollbacks or reverts.

any info is welcomed.

Is Appian Case Management a framework or just a coding style?

ahmadb3492 — Fri, 17 Oct 2025 11:14:52 GMT

Hello Appian Community,

I’m exploring Appian Case Management and came across some implementations described as “case management style.” However, when researching, I see references to Appian Case Management as a native framework.

Observations from typical implementations:

Short-lived processes triggered on UI submission

Routing logic partly handled via staric Match() expressions

State stored in database tables

Audit/history maintained manually in tables

My questions:

1. In Appian, is Case Management a native framework that you configure, or is it just a coding style/pattern?

2. How can we objectively distinguish a true case management implementation from a hybrid or DB-driven workflow that only simulates case management?

3. Are there official Appian guidelines or best practices confirming this?

Thank you for your guidance!

Logging Interface Access

Keizo Watsuji — Mon, 13 Oct 2025 08:48:26 GMT

I hope this message finds you well.

I would like to log the event of an interface being opened.
However, my understanding is that on the interface itself, unless an action such as clicking a button occurs,

it is not possible to write a record or start a process model.

When consulting ChatGPT, I received the following idea:

Create a Web API on Appian that returns an image as the response and simultaneously saves a log.
Place an image on the target interface and set the endpoint of the Web API created in (1) as the image source.
As a result, when the interface is opened, the Web API in (1) is called, and the log is recorded.

However, it seems that the function a!writeToDataStoreEntity does not get triggered inside the Web API.

I have two questions and would appreciate your advice:

What should I review to implement the above ChatGPT idea successfully?
Are there alternative methods to log when an interface is opened?

Thank you in advance for your kind advice.

DataSubset & Rule Reference Question

GautamShenoy — Fri, 26 Sep 2025 11:18:31 GMT

Hi Team,

I had 2 simple questions which I wanted to post here. Please help me if anyone has the answers :

Context :

You are given a list of CDT / Dictionary / Map with a few fields, eg :

{ { key: 12, val: "ABC" }, { key: 20, val: "DEF" }, { key: 30, val: "GHI" } }

Problem statement :

Get those CDTs which have key bw 10 & 25

My approaches :

I had 2 approaches, both of which I have a roadblock

I convert this to list to a data subset using toDataSubset function and then filter on this
I create a rule which takes this `key` as an RI and then returns true / false based on condition. I will use this rule in the filter function and use wherecontains to filter out which matches our condition

Questions :

Now for the approach 1, I had a question : how do I filter this custom data subset ? because I only see queryEntity and queryRecord but nothing to query this custom dataset

For approach 2 : is there a way we can eliminate the need of creating a different rule in the env and somehow use some function .. is it possible to create local functions in appian ? something like :

a!localVariables(
  local!a:  (var){
    
  }
)

Choosing Between Appian’s Built-In Human Tasks vs Custom Task List Database

ahmadb803565 — Thu, 18 Sep 2025 09:52:03 GMT

Hi Appian Team and Community,

We’re designing a generic, audit-compliant task module to support multiple business processes—KYC, retail and corporate loan origination, ESG, and more. Before finalizing our architecture, I’m weighing two approaches for task management:

Option 1: Appian’s Built-In Human Tasks via Process Models

Uses process reports and task assignment rules
Tasks are tied to process instances
UI and SLA logic driven by Appian’s native task engine

Option 2: Custom Task List Database

We build our own TASK_GROUP and TASK tables
Tasks are instantiated based on business rules and metadata
UI, counters, and SLA logic are fully controlled via record types and expressions

My Questions:

If we rely on Appian’s built-in human tasks, what happens if the process instance is deleted or archived? – Can we still access task metadata (status, assignee, timestamps) via process reports or APIs?
What are the trade-offs between using Appian’s native task engine vs a custom task registry? – Especially in terms of auditability, lifecycle control, and cross-process reuse
Is it common practice in enterprise-grade implementations to build a custom task pool for traceability and reporting? – Or do most teams rely on Appian’s built-in task management?

For context: our vendor recommended the database-driven approach, citing limitations in Appian’s native task handling—particularly around long-term traceability, cross-process reuse, and lifecycle control once processes are deleted. That inspired us to explore a fully generic task registry that can support dynamic instantiation and stage-based progression across domains.

We’re aiming for a scalable, future-proof design that supports dynamic task instantiation based on business rules, stage-based progression, and full audit history. I’d love to hear how others have approached this, and what Appian recommends for long-term maintainability.

Thanks in advance!

error converting typed value TypedValue

sireesha — Mon, 15 Sep 2025 16:10:29 GMT

Hi Everyone,

I am getting below error could you please let me know if you have any idea on this error

error converting typed value TypedValue[it=1134,v={4cef5fb4-6aa9-499c-99e1-34fbb0d20616@6291,{TypedValue[it=5246,v={335,C-2025-0335,,,Efficacy and safety of liposomal amphotericin B(AmBisome® ) versus Isavuconazole in patients with invasive Aspergillosis in liver transplant recipients ,,,CRDRF,DRF,<null>,,jiaqi wei,2025-09-13,<null>,110000.0,0,,0,,<null>,1,15144486065@163.com,2025-09-13 01:56:30.0,<null>,15144486065@163.com,2025-09-13 02:28:22.48,,1,Shawn.xiao,,0,}]}}] to XML in order to convert it to java type com.appiancorp.common.EntityData

Appian Smart Search capability

sanjuktab2257 — Thu, 11 Sep 2025 04:27:59 GMT

We have created an Expression Rule named abc, where data is fetched from a Record Type with Smart Search enabled. The results are sorted in descending order of similarity score.

Smart Search is enabled on the Full Name and Address fields. For example, the address field contains values like "St.", and we expect that when a user searches for "Street", addresses containing "St." should receive the highest similarity scores.

However, we are observing unexpected behavior. For instance, the address "1817 W Broadway Columbia MO 65218" sometimes receives a higher similarity score than addresses that explicitly contain "St.".

Additionally, we would like to understand how Smart Search handles nickname matching—for example, whether a search for "Leo" would return results like "Leonardo" with a high similarity score.

Request:

Could you please help us understand how similarity scores are calculated in Smart Search?
Is there documentation or guidance on how abbreviations (e.g., "St." vs "Street") and nicknames are handled?
Are there any best practices or configuration tips to improve the accuracy of semantic matching in such cases?

Any updates on JMeter for Appian?

Evan — Mon, 08 Sep 2025 15:25:09 GMT

According to Leverage JMeter in Appian Load Testing, this plug-in JMeter for Appian is needed for, or at least greatly streamlines, performance testing in Appian. The app is now unavailable, and a comment on the plug-in page notes that it is out of date. Is this plug-in permanently out of support, and consequently, is that a showstopper for using JMeter in Appian Load Testing? What is the latest guidance?

I need a right answer for this question.

aftabs332977 — Fri, 29 Aug 2025 09:49:10 GMT

Q. There are 2 record types, ABC and XYZ, which sync enabled. The XYZ record type is added as a relationship into the ABC record type. A user has Viewer permission to the ABC record type but does not have access to the XYZ record type. A site page is represented to the user where the data is sourced from the ABC record type and its related record type the XYZ reference. What information does the user see on the site page?

Page is presented to the user and the data reference to the XYZ record type appear as “null”
Page is presented to the user with the XYZ record type data and field references redacted.
Page does not load, and an error message is presented: “The record type [identifier=XYZ] does not exist, has been deleted, or you do not have sufficient privileges to access the data.”

Send Email Smart service issue - Health Check Report

prathipatir576008 — Fri, 22 Aug 2025 12:17:27 GMT

Hi Community,

In our current implementation, we're using the Send E-Mail smart service in a few process models. However, the Appian Health Check report flagged this with the following message:

"Send E-Mails references a smart service that is no longer recommended for use (Send E-Mail). Please remap this node in the process model to use the latest version."

Could someone guide us on:

What the recommended replacement is for the deprecated Send E-Mail smart service?
Any best practices or migration steps we should follow while updating our process models?

Thanks.

What is the most effective way to implement version control for an Appian application deployed across multiple environments?

sanjuktab2257 — Tue, 12 Aug 2025 13:29:16 GMT

Initially, I considered using deployment packages to track changes. However, I noticed that once changes are pushed from UAT to Production, the environments become synchronized. As a result, all objects appeared in the deployment package; however, the ones that were initially modified before being pushed to Production are no longer listed as 'modified.' This makes it difficult to track the specific changes made during that deployment.

I'm looking for a reliable approach to maintain visibility into code changes with each deployment. Has anyone found a good solution or best practice for this scenario?

Database Design vs. JSON Blueprint – Best Practice for Centralized Document Handling Across Bank Processes

ahmadb803565 — Tue, 15 Jul 2025 06:57:51 GMT

Hi everyone, We’re currently in the design phase of a large-scale Appian BPM implementation for a bank. Appian acts as the backend processor for multiple business domains — including Loan Origination, KYC, and more — with all front-end channels (like CRM) integrating via Kafka events.

To give context, here’s a simplified version of the incoming JSON payload from CRM to our Appian BPM:

Our Design Question We’re wondering whether our database design should mirror this JSON structure, or whether we should use a normalized model that separates document references into a central table. To scope the question further: We’re using a DMS (Document Management System), and every attachment UUID points to a file stored there. Documents can belong to any entity (Applicant, Collateral, Product Info, etc.), and multiple documents can be associated with each entity. Processes vary, and different document types may be required at various stages (requested from the CRM during the ongoing process).

Our Questions to the Community

1. In your Appian projects, do you follow the incoming JSON structure when designing your database schema — or do you normalize?

2. Do you recommend a centralized DOCUMENT_LOG model for document storage across multiple processes/entities?

3. How do you manage document associations when IDs (e.g., applicant_id) are only available after insert and we insert them at once?

We appreciate any insights or architectural lessons from large-scale Appian use cases!

{
"meta": {
"process": "Retail.Murabaha.CarLoan.CreditReview",
"eventType": "START_CREDIT_REVIEW",
"source": "CRM",
"destination": "BPM",
"isSynchronously": false,
"isAcknowledgment": true,
"correlationId": "abc12345-0000-1111-2222-1234567890ab",
"transactionId": "def67890-0000-2222-3333-0987654321ba",
"submittedBy": 1936,
"timestamp": "2024-10-31T10:15:30Z"
},
"data": {
"application": {
"branchCode": "1010",
"submissionDate": "2024-10-31T10:15:30Z",
"requestedAmount": 10000.0,
"currency": "JOD",
"tenorMonths": 60,
"gracePeriodMonths": 0,
"annualProfitRate": 5.5,
"dbr": {
"standardRatio": 40,
"excludingStandingLoans": 40,
"includingPendingRequests": 40,
"withJoalaVisa": 40,
"guarantorDebtor": 40,
"overIndebtedness": 40
},
"productInfo": {
"fuelType": "1",
"carStatus": "1",
"newCarOwnerName": "Sara Mahmoud",
"relationshipType": "None",
"carBrand": "Toyota",
"carType": "Sedan",
"productionYear": 2022,
"chassisNumber": "ABC123456XYZ",
"insuranceType": "1",
"expiryOfLicense": "2025-12-31",
"extraComments": "No remarks",
"totalPrice": 35000.000,
"greenFinancing": true,
"typeOfGreenFinancing": "text",
"expectedOwners": [
{
"excpectedCarOwnerName": ""
}
],
"currentOwners": [
{
"ownershipIdentityNumber": "",
"currentOwnerName": "Mohammad Ali",
"currentOwnerStatus": "1",
"isCurrentOwnerGuarantor": false,
"safewatch": {
"existInSafewatchList": true,
"complianceDecision": "CSS007",
"notes": "",
"attachments": {
"safewatch": "1e0a2ee5-9284-4380-ac6b-0548c817fd74",
"compliance": "32378b57-3873-48f5-9859-2f27476fd73f"
}
},
"attachments": {
"vehicleOwnershipProof": "42378b57-3873-48f5-9859-2f27476fd73f"
}
}
],
"attachments": {
"carLicenseAttachment": "ff135649-ddae-4f7f-acc7-4720e2c16aa7"
}
},
"collaterals": {
"suggested": [
{
"collateralNumber": 123456,
"collateralAmount": 456.000,
"collateralExpiryDate": "2020-01-15",
"conditionDetails": "1",
"Recommendations": "comments",
"collateralType": 23,
"collateralTypeDesc": "Salary Tranfers",
"collateralLongName": "0",
"collateralBriefName": "راتب",
"attachments": [
{
"collateralAttachment": "6d89e0f2-c03f-4d99-a983-6335f6632729"
}
]
}
],
"recommended": [
{
"collateralNumber": 123456,
"collateralAmount": 456.000,
"collateralExpiryDate": "2020-01-15",
"conditionDetails": "1",
"Recommendations": "comments",
"collateralType": 23,
"collateralTypeDesc": "Salary Tranfers",
"collateralLongName": "0",
"collateralBriefName": "راتب",
"attachments": [
{
"collateralAttachment": "6d89e0f2-c03f-4d99-a983-6335f6632729"
}
]
}
]
},
"applicants": [
{
"cif": 48001082,
"personalInfo": {
"fullNameEnglish": "Mohamed Ahmed Ali",
"attachments": {
"cbjConsent": "0c6f7cfd-87c0-4bb3-bf9c-ed76adc97e8f",
"crifConsent": "1bbefd21-f07f-4e97-99b5-9a27a7761335",
"cspdConsent": "1c5badcc-de50-4c97-9b82-4911addaca71"
}
},
"identityInfo": {
"idNumber": "123456789",
"attachments": {
"idCopy": "5a919a5d-3a43-4b49-81fb-b8af9e4fc850"
}
},
"contactInfo": {
"addressEnglish": "Amman, Queen Rania Street",
"mobileNumber": "123456789"
},
"workInfo": {
"employerClassification": "2",
"employerName": "Tech Corp"
},
"financialInfo": {
"salaryAmount": 500.000,
"salaryDetails": [
{
"monthYear": "01-2023",
"amount": 500.000
},
{
"monthYear": "02-2023",
"amount": 500.000
}
],
"attachments": {
"salaryCertificates": "5a919a5d-3a43-4b49-81fb-b8af9e4fc850",
"socialSecurityStatement": "0c6f7cfd-87c0-4bb3-bf9c-ed76adc97e8f",
"soa6Month": "1bbefd21-f07f-4e97-99b5-9a27a7761335",
"clearanceDetails": "1c5badcc-de50-4c97-9b82-4911addaca71"
}
},
"standingLoans": [
{
"loanType": "Personal",
"collaterals": [
{
"collateralAmount": 456.000
}
]
}
],
"insuranceInfo": {
"hasDiseases": false
},
"crifInfo": {
"creditCardOutstanding": 5000.000,
"dbr": 0.3,
"creditRiskLevel": "Low"
},
"clearanceInfo": {
"name": "أحمد خالد سعيفان"
},
"safewatch": {
"existInSafewatchList": true,
"complianceDecision": "CSS007",
"notes": "",
"attachments": {
"safewatch": "68661ab6-2573-4288-9a66-6a8f9e63454f",
"compliance": "cc73516f-eff6-4713-8202-d0b2e5ddfa09"
}
}
}
],
"delegators": [//same as applicant json structure],
"guarantors": [//same as applicant json structure]
}
}
}

How Should We Handle Documents in Enterprise BPM with Appian + DMS?

ahmadb3492 — Sun, 13 Jul 2025 19:47:10 GMT

Hi everyone,

We’re building a large BPM platform in Appian for a bank. It handles multiple core processes like Loan Origination, KYC, and other services. We’re also integrating with both CRM and a Document Management System (DMS) — so document handling is a key topic for us.

Our Setup

CRM sends us structured application data via Kafka events.
We use a central table called BPM_PROCESS_MASTER to track each case (with caseId, correlationId, processKey, etc.).
We built a shared table BPM_DOCUMENT_LOG to store documents with fields like:
- processId
- entityType
- entityRefId
- documentType
- AppianDocId (if it’s stored in Appian)
- DMS_UUID (if it’s stored in our DMS)

This setup gives us flexibility:

We can store documents at any level (applicant, guarantor, collateral, etc.)
We can handle new document uploads mid-process (like if Credit asks CRM to re-send more docs)
It keeps our business data clean and avoids spreading document fields everywhere

But We’ve Hit Some Friction

Our vendor is pushing back. They want to store document references inside each business table (like APPLICANT, COLLATERAL, etc.).
Not only that — they also want to create dedicated relationships for each document inside those tables, meaning that for every document, there would be a foreign key column in the business entity pointing to the DOCUMENT_LOG.
For example:

APPLICANT would have columns like cbjConsentDocId, idCopyDocId
COLLATERAL would have collateralAttachmentId, etc.

This tightly couples documents to each business entity, and makes our model less flexible, especially considering:

New documents may be requested during the process
Document types differ by process (e.g., KYC vs Loan)
Some documents exist only in DMS (not Appian)

We believe a centralized and normalized DOCUMENT_LOG table is more scalable across processes and systems.

They say:
The vendor mentioned Appian has a 3-level relationship depth limit, which makes saving deeper/nested data and documents together challenging, especially in bulk operations.

Additionally, the vendor raised a concern around bulk inserts of related entities like applicants and collaterals: when inserting many records at once, Appian returns generated IDs but does not specify which ID corresponds to which entity in the payload. This makes it difficult to correctly link multiple uploaded documents to their respective entities.

Honestly, this sounds more like a workaround than a limitation. But we want to do it right — and follow real best practices.

Our Questions to You

Is Appian really limited in a way that prevents us from using a shared DOCUMENT_LOG table?
Is it better to keep document references in a centralized table, especially when we deal with:
- Multiple processes
- DMS integration (not just Appian documents)
- Mid-process uploads
How do others handle this in large-scale or event-driven setups?

We’d love to hear how others approached this — or if we’re missing something important.

Thanks in advance!

CRM To Appian simplified sample JSON payload
{
"meta": {
"process": "Retail.Murabaha.CarLoan.CreditReview",
"eventType": "START_CREDIT_REVIEW",
"source": "CRM",
"destination": "BPM",
"isSynchronously": false,
"isAcknowledgment": true,
"correlationId": "abc12345-0000-1111-2222-1234567890ab",
"transactionId": "def67890-0000-2222-3333-0987654321ba",
"submittedBy": 1001,
"timestamp": "2025-07-13T12:00:00Z"
},
"data": {
"application": {
"applicationType": "1",
"branchCode": "1000",
"submissionDate": "2025-07-13T12:00:00Z",
"requestedAmount": 15000.0,
"currency": "USD",
"tenorMonths": 48,
"annualProfitRate": 6.0,
"totalAmount": 18000.0,
"installmentAmount": 375.0,
"productInfo": {
"carBrand": "GenericCar",
"carType": "Sedan",
"productionYear": 2020,
"attachments": {
"carLicenseAttachment": "uuid-car-license-001"
}
},
"applicants": [
{
"cif": 12345,
"personalInfo": {
"fullName": "John Doe",
"nationalId": "A123456789"
},
"attachments": {
"idCopy": "uuid-id-copy-001"
}
},
{
"cif": 12346,
"personalInfo": {
"fullName": "Jane Smith",
"nationalId": "B987654321"
},
"attachments": {
"idCopy": "uuid-id-copy-002"
}
}
],
"collaterals": [
{
"collateralType": "Vehicle",
"collateralAmount": 10000.0,
"attachments": {
"collateralAttachment": "uuid-collateral-001"
}
}
]
}
}
}

Connecting to S3 via PrivateLink

Meme02 — Thu, 10 Jul 2025 04:58:22 GMT

Hi there,

As a result of a process, a CSV file is output, and I want to store that file in AWS S3. Also, when needed, I want to be able to copy the file in S3 to the Appian Knowledge Center by pressing a button.

I want to achieve this by connecting via AWS Private Link, not via the internet.

To achieve this, is there any way other than using Lambda, etc.?

There is an Amazon S3 Utilities plugin, but it seems to connect via the internet, so I don't think it meets the requirements.

Thanks