Database Transaction Standardization and Deadlock Guidance (v1.27.425+)
Audience: Administrators, Solution Builders, Workflow Designers Skill Prerequisites: Basic SQL, understanding of workflows and Run SQL actions Applies To: Plant an App v1.27.425 and later (including v1.28+) Purpose: Explain the transaction handling changes introduced in v1.27.425+, clarify real-world concurrency impacts, and provide best practices and mitigation strategies.
Why This Change Matters
Prior to v1.27.425, some database connections could unintentionally retain a SERIALIZABLE isolation level due to ADO.NET connection pooling combined with TransactionScope usage.
This resulted in:
- Intermittent and difficult-to-reproduce deadlocks
- Inconsistent behavior across identical operations
Starting with v1.27.425, Plant an App standardizes transaction handling to ensure all operations execute consistently using READ COMMITTED isolation.
👉 This is a correctness and consistency improvement, not a change in the intended concurrency model.
Who Should Care
This change is especially important for:
- High-concurrency environments (APIs, webhooks, heavy user activity)
- Applications using Run SQL actions extensively
- Systems integrating with external databases via ODBC (e.g., Sage 300)
- Workflows that perform frequent read/write operations on shared data
If your system processes many concurrent operations or interacts with external data sources, this change may have a noticeable impact.
TL;DR
- The platform now runs all database operations inside transactions
- Behavior is now consistent and predictable
- Some existing issues may now show up as repeatable deadlocks
- These are not new problems—they were previously hidden
- ⚠️ Some external systems (like certain ODBC connections) fail inside a transaction
- ✅ Workaround (v1.28, May 20, 2026 hotfix): turn off Use Transactions in the Run SQL Query action for those systems
Overview
Starting with version 1.27.425, Plant an App standardizes database transaction handling across all operations.
Key changes include:
- All SQL execution is wrapped in an explicit transaction
- All transactions use READ COMMITTED isolation
- All
TransactionScopeusage explicitly enforces READ COMMITTED
This eliminates prior inconsistencies caused by connection pooling and ensures deterministic execution behavior.
What Changed
Before v1.27.425
- SQL connections were reused via ADO.NET connection pooling
- Some operations (e.g., form save/load) used
TransactionScopewithout explicitly enforcing READ COMMITTED - This could elevate isolation level (e.g., SERIALIZABLE)
- Elevated isolation levels could persist across pooled connections
- Subsequent queries might unknowingly run under stricter rules
👉 Result:
- Inconsistent behavior
- Intermittent and hard-to-diagnose deadlocks
After v1.27.425
- All SQL execution is explicitly wrapped in a transaction
- Isolation level is consistently READ COMMITTED
TransactionScopeis still used, but now explicitly controlled- Connection pooling no longer leaks isolation levels
- Execution behavior is deterministic and predictable
👉 Result:
- Improved consistency and correctness
- Previously hidden concurrency conflicts may now surface as repeatable deadlocks
External System Compatibility (Important)
Some external systems—particularly those accessed via ODBC (such as Sage 300)—do not support explicit transactions.
Because Plant an App executes SQL within a transaction by default:
- These integrations may fail with errors such as: “Transactions are not supported”
❗ Important:
- Since the May 20, 2026 hotfix for v1.28, the Run SQL Query action has a Use Transactions option. It's on by default. Turn it off for an external system that doesn't support transactions.
- On versions from 1.27.425 up to that hotfix, there is no workaround. Upgrade to the latest v1.28 hotfix, or remain on a version prior to 1.27.425.
Important Clarifications
This Is Not a New Concurrency Model
This change does not introduce new concurrency behavior.
Instead, it:
- Removes unintended SERIALIZABLE isolation behavior
- Applies consistent transactional boundaries
- Makes concurrency behavior predictable
- Surfaces conflicts that were previously intermittent or hidden
Deadlocks Are Not New
Deadlocks observed after upgrading are not newly introduced.
👉 These conflicts already existed but were:
- Inconsistent
- Difficult to reproduce
- Sometimes hidden by unintended isolation behavior
Now they are:
- Consistent
- Repeatable
- Easier to diagnose and fix
How Deadlocks Occur (Simplified)
When operations run inside transactions, they interact with data in a defined sequence.
Deadlocks occur when:
- One operation accesses data in one order (e.g., Table A → Table B)
- Another operation accesses the same data in a different order (e.g., Table B → Table A)
👉 Each operation ends up waiting on the other, creating a circular dependency.
In high-concurrency environments:
- More operations run at the same time
- More overlapping access occurs
- The likelihood of conflicting sequences increases
Why Deadlocks May Increase After Upgrade
After v1.27.425:
- More operations are consistently transactional
- Execution order is now predictable
- Overlapping operations are more clearly exposed
👉 As a result:
- Existing concurrency conflicts now appear as repeatable deadlocks
These deadlocks are not new—they are now surfaced consistently because reads and writes participate in the same transactional model.
High-Concurrency Environments (Important)
Systems with high request volume may observe more frequent deadlocks after upgrading.
This typically indicates:
- Competing updates to shared data
- Inconsistent update ordering
- Overlapping operations across workflows
👉 The benefit:
- These issues are now easier to identify and correct
Platform Constraints
In v1.27.425 and later:
- Transactions are enabled by default
- Isolation level is fixed to READ COMMITTED
- In Run SQL Query, transactions can be turned off with Use Transactions (from the May 20, 2026 hotfix for v1.28). The isolation level isn't configurable.
👉 Deadlock mitigation must be handled at:
- Workflow design level
- SQL design level
- Database schema/indexing level
Common Low-Code Patterns That Cause Deadlocks
1. Inconsistent Update Order Across Workflows
-- Workflow A
UPDATE Contacts ...
UPDATE Visits ...
-- Workflow B
UPDATE Visits ...
UPDATE Contacts ...
👉 Conflicting order increases deadlock risk
2. Long-Running Run SQL Actions
SELECT ...
-- processing
UPDATE ...
👉 Longer operations increase overlap between concurrent executions
3. Bulk Operations and Batch Processing
- Entity imports
- Loop-based updates
- Bulk inserts
👉 Larger operations increase contention
4. Read-Then-Write Patterns
SELECT * FROM Table WHERE Id = X
-- logic
UPDATE Table SET ... WHERE Id = X
👉 Multiple processes may collide after reading the same data
5. Missing or Inefficient Indexing
- Table scans increase scope of data access
- More data is touched than necessary
👉 Increases likelihood of conflicting operations
6. Parallel Workflow Execution
- Multiple users submitting forms
- Scheduled jobs running simultaneously
- API/webhook triggers
👉 Increased concurrency leads to higher conflict probability