This page is written for the person who has to review us. If your finance team is considering an automation partner and it has landed on your desk to assess, this sets out how we handle credentials, what the audit trail gives you, how errors behave, how changes are controlled, and how we decide between an API integration and RPA. No marketing claims, and nothing you would otherwise have to ask for in a questionnaire.
One service account per integration, scoped to the objects it touches, documented at handover
Secrets live in a managed store. We never ask for a named user's password
Bounded retries for transient faults, no retry for validation failures, alerting on the run that never started
Posting logic, matching rules and thresholds are versioned and reviewed. Nothing is edited live
The short version, for a reviewer who needs an answer before a meeting. Each item is expanded further down.
| Area | Our standard |
|---|---|
| Identity | One named service account per integration. Never a shared credential, never a named person's login, never an account with broader rights than the integration uses |
| Credentials | Stored in a managed secret store, yours where you have one. Never in source control, configuration files, scripts or a ticket |
| Network | Outbound to documented vendor endpoints over TLS. Where you require source IP restriction we work within it; we do not ask for inbound access to your network |
| Data | We work in your tenant wherever the platform allows it. Where data must move, the minimum fields for the purpose, with retention agreed in writing |
| Audit trail | Every entry carries a source reference to the originating transaction. Platform audit trail plus our own run log, both retained |
| Error handling | Transient faults retried with backoff and a cap. Validation failures held, never retried. Nothing silently dropped |
| Change control | Version control, peer review, release record. Posting logic and matching rules are code, not configuration someone edits at month end |
| Testing | Build and test against a non-production instance. A parallel run of at least one full close before anything manual is switched off |
| Handover | Runbook, permission specification, change process, escalation path. Written so your team can operate it without us |
The first question a security reviewer asks is what we will have access to and how that access is held. These are our standard, not an upgrade available on request.
A dedicated service account in each system in scope, created by you, with permissions scoped to the objects the integration reads and writes. A non-production instance for build and test with representative data, wherever the platform offers one. Documentation access, and a named technical contact for questions that need a decision.
A named individual's login. If a requirement would need one, we will tell you the integration needs redesigning instead. Administrator rights where a scoped role will do. Production write access during build. Credentials sent by email, chat or ticket. Standing access after handover.
Where we supply engineers who work in your team rather than delivering a scoped build, those people work under your access policies and your onboarding, not ours. That model is described on how we work and our page for IT services companies.
Finance platforms log who changed what and when. That tells an auditor the integration made an entry. It does not tell them which transaction caused it.
Entries created by an integration join the journal entry population your auditor tests for fraud.
The PCAOB's 2025 staff guidance on journal entries states that management-override risk applies to entries processed through automated systems, not only manual ones, and that the population examined must be tested for completeness. So we add two things the platform cannot give you: a source reference on every entry leading back to the originating transaction, and a run log that records what each execution read, wrote and rejected, with counts and values on both sides. That log is the evidence for any control relying on the automation, retained on terms agreed with you rather than rotated away at a default interval.
A finance automation should fail in a way that is loud, attributed and recoverable.
| Failure class | Retry policy | Who hears about it, and when |
|---|---|---|
| Transient: timeout, throttling, connection reset | Bounded retry with exponential backoff and a cap | Nobody, unless the cap is reached. Then an engineer, immediately |
| Validation: bad dimension, closed period, rejected field | No retry. Retrying produces the same rejection | The exception queue, with the platform response translated into accounting language |
| Partial run failure | Safe replay of the whole run, because posting is idempotent | An engineer immediately; finance sees it in the run reconciliation |
| Duplicate submission risk | Prevented, not recovered. Replay protection or a client-side key checked before write | Nobody. It should never reach the ledger |
| The scheduled run never started | Not applicable | An alert the same morning, from heartbeat monitoring on the schedule itself |
| Volume anomaly: far more or fewer records than expected | Run halts before writing | An engineer and the finance owner, before anything posts |
The last two are what most implementations miss. A run that never started produces no error log, so log-based alerting cannot see it. The schedule needs its own heartbeat. And a run processing ten times the usual volume is usually a bug upstream rather than a busy day; halting before writing is cheaper than reversing afterwards.
If your organisation is in scope for SOX, the automation sits inside IT general controls. A reviewer will test it there, so it is built to be testable there.
Posting logic, matching rules, thresholds and mappings live in version control, not in a configuration screen somebody edits at month end. Every change has a ticket, a reviewer other than the author, and a release record produced by the process rather than written up afterwards. Where you have your own change process, we work inside it.
A change log covering the life of the automation, attributable to a person. The permission specification for every service account. Evidence of segregation of duties, with the service account mapped against the same conflict matrix a person would be, documented before build rather than after a finding. Parallel run evidence from go-live, signed by the control owner.
Worth noting in the other direction, because it rarely gets said: PCAOB AS 2201 treats automated controls as generally lower risk where IT general controls are effective, and permits a benchmarking approach for automated application controls in later years. A well-controlled automation can reduce annual testing effort rather than add to it.
Only if the control evidence exists, which is why we produce it during build.
We state this plainly because it is often the reviewer's real question. The decision is made per step rather than per project, and documented in the interface assessment before build.
| Condition | Approach | Why |
|---|---|---|
| The system has a documented, supported API | API integration | Transactional, restartable, logged at both ends, unaffected by a user interface change |
| An API exists but does not expose the object required | API plus a supported import route | Stays inside interfaces the vendor supports, which is what the vendor will help with when it breaks |
| The system is desktop-only or has no API | The vendor's supported exchange, then RPA | QuickBooks Desktop exchanges qbXML through the Web Connector, a supported interface. Driving the desktop client with a robot is not |
| A portal with no API and no export | RPA, with monitoring and an exception queue | Correct where no interface exists. It gets an owner because it will break when the portal changes |
| The step requires judgement or context | Not automated | Routed to a person with the data assembled and the decision framed |
From a security standpoint the distinction matters beyond reliability. An API integration authenticates as a scoped service account with permissions you can enumerate. A screen automation authenticates as whatever the user interface requires, which is often a broader set of rights than the task needs. Where RPA is unavoidable we will say so, scope the account as tightly as the interface permits, and state the residual risk rather than describing it as equivalent.
Everything on this page applies to every finance automation we build. Each page below is written for a different reader.
The full scope: accounts payable, subledger-to-ledger flows, reconciliation, collections, close and master data, plus how an engagement is staged.
Send your finance team here →Posting rules and grain, duplicate prevention using the platform's own replay protection, error routing, and what the Intacct audit trail does and does not give you.
Read the detail →The three-way match, why processor payouts never equal the day's transactions, and how the exception queue is designed to be audit evidence.
Read the detail →What IT and security reviewers raise before approving a finance automation engagement.
A dedicated service account in each system in scope, created by you, with permissions scoped to the objects the integration reads and writes, and a non-production instance for build where the platform offers one. We do not ask for a named individual's login, administrator rights where a scoped role will do, or production write access during build. Access is removed at the end of the engagement unless a support arrangement says otherwise in writing.
In a managed secret store, yours where you have one, so the credential never leaves your control. Never in source control, configuration files, scripts, email, chat or a ticket. If your process requires a specific credential exchange method, we use it. If you require rotation on a schedule, the integration is built to handle rotation without an outage, which is a design decision rather than something retrofitted.
Three mechanisms. Every run produces a reconciliation: count and value read against count and value written, with any difference explained. The schedule has its own heartbeat monitor, so a run that never started raises an alert rather than producing no log at all. And a volume anomaly halts the run before it writes anything, because ten times the usual record count is almost always a bug upstream rather than a busy day.
It creates ITGC scope, which is not the same as a problem. The automation sits inside logical access, change management and operations, so it is built to be testable there, with versioned logic, peer-reviewed changes, a release record, a documented permission specification and segregation-of-duties mapping done before build. Worth knowing in the other direction: PCAOB AS 2201 treats automated controls as generally lower risk where IT general controls are effective, and permits a benchmarking approach in later years.
Only where a system exposes no interface, which in finance usually means a bank or government portal. It is a legitimate concern, and the honest answer is that a screen automation authenticates as whatever the user interface requires, which is often broader than the task needs. Where it is unavoidable we scope the account as tightly as the interface permits and state the residual risk rather than describing it as equivalent to an API integration.
We work inside your tenant wherever the platform allows it, so the data does not move. Where it must move, and document extraction is the usual case, only the fields needed for the purpose go, and retention is agreed in writing rather than left to a default. We are happy to complete your own security questionnaire and to work within data residency requirements; raise those at the first conversation rather than at contract stage.
If something here does not meet your standard, or your questionnaire covers ground this page does not, send it over. We would rather answer it now than discover a blocker after your finance team has committed to a timeline.
Tell us what you need. We will send curated profiles within 4 days.