When an Appian integration changes data, OnSuccess and OnError callbacks help guide what happens next. One can trigger follow-up actions after a successful update; the other supports clear error handling. Together, they help keep workflows dependable and data changes easier to manage.

Multiple Choice

What additional parameters are added by default when modifying data through an integration?

When modifying data through an integration in Appian, additional parameters that get added by default include OnSuccess and OnError. The OnSuccess parameter is used to define the actions or events that should occur if the data modification is successful. This could involve triggering subsequent processes, sending notifications, or updating user interfaces based on the successful outcome. OnError, on the other hand, specifies the actions that should take place in case an error occurs during the data modification process. This is crucial for error handling and ensures that the system can robustly manage exceptions, offering fallback procedures, alerting users, or executing alternative logic to maintain data integrity and improve user experience. Together, these parameters enhance the integration's ability to respond appropriately to different outcomes of the data modification process, making it more reliable and user-friendly. In contrast, the other options present parameters that do not align with the standard default additions during data integration. They might pertain to different contexts within the application lifecycle, but they do not accurately describe the parameters that are automatically included when modifying data through integration.

Handling Success and Errors in Appian Integrations

When an Appian interface changes data through an integration, the request is only part of the story. The application also needs a clear way to respond when the change succeeds—and when it doesn’t. Appian provides two useful outcome hooks for that job: OnSuccess and OnError.

These parameters help an interface react to the result of a data modification. One can move the user forward after a successful update; the other can guide the application when something goes wrong. Used thoughtfully, they make integrations feel less like a black box and more like a well-connected part of the user experience.

A data change needs a response

An integration sends a request to another system, such as a service that creates, updates, or deletes data. The external system processes that request and returns a response. Sometimes the result is straightforward. At other times, the service may reject the request, take too long to respond, or return information the application can’t use.

A user shouldn’t have to guess what happened. Did the update save? Should they try again? Has the system accepted the request but not finished processing it? Appian’s outcome handling helps answer those questions by giving the interface a place to respond to different results.

That’s where OnSuccess and OnError come in. They describe what the application should do after an integration call ends in success or error. The names are simple, but the design choices behind them matter.

OnSuccess: make a good result feel clear

OnSuccess defines the response to a successful data modification. For example, after an update succeeds, an interface might show a confirmation message, refresh a record view, or navigate the user to a related screen. A process could also continue with a follow-up action, depending on how the integration is used.

The key is to make the next step match the work that just happened. If a user changes a contact’s phone number, a brief confirmation may be enough. If they submit a request that triggers several downstream actions, the interface might explain that the request was accepted and show its current status.

Success does not always mean that every related task has finished. An external service might accept a request and then complete its work later. In that case, the interface should avoid promising more than the service has confirmed. “Request submitted” may be more accurate than “Everything is complete.” That small difference can save users from confusion later.

A useful success response is also timely. If the interface shows no feedback, a user may click the button again. That can create duplicate requests or records, especially when the original call succeeded but the confirmation was delayed. A clear message helps prevent that second click from becoming a second transaction.

OnError: respond without losing the thread

OnError defines what should happen when the data modification encounters an error. The application might display a message, keep the user’s current work on screen, offer a safe retry, or route the issue to an appropriate support path.

The best response depends on the kind of error. A temporary service outage may call for a calm message and a retry option. A validation failure may need a specific explanation, such as a required field that’s missing or a value the service won’t accept. A permissions issue should be handled differently again: asking the user to retry won’t help if they lack access.

This is why a vague message like “Something went wrong” can be frustrating. It may be better than showing raw technical details, but it offers little guidance. A user-friendly message should say what they can do next, when that’s known. For instance: “The update wasn’t saved. Check the highlighted fields and try again.” If the issue is outside the user’s control, say that plainly and explain whether the data remains unchanged.

There’s a balance to strike here. Detailed error information can help developers diagnose a problem, but exposing internal service responses directly may confuse users or reveal information they shouldn’t see. Good error handling separates the message meant for the person using the interface from the diagnostic details meant for logs or support teams.

Treat outcomes as part of the interface

It’s tempting to focus on the integration call itself: the endpoint, request body, authentication, and returned data. Those pieces are important, of course. But a well-built interface also considers what happens after the call. Success and error handling shape how dependable the feature feels, even when the underlying service is outside Appian’s control.

Think of an integration as a handoff between two teams. Appian sends a request; another system takes it from there. OnSuccess and OnError help the first team respond once the handoff has a known result. They don’t make an unreliable service reliable by themselves, but they do give the application a structured way to handle outcomes.

That structure is especially useful when several actions depend on the result. A successful update might refresh displayed data, close a dialog, or trigger a later process. An error might leave the dialog open so the user can correct a value. Keeping these responses close to the relevant action makes the interface easier to understand and maintain.

Build useful error paths, not just happy paths

A successful call is the outcome everyone hopes for, but integrations live in the real world: networks pause, services change, and input data doesn’t always fit. It’s worth considering those cases while designing the feature rather than adding an error message as an afterthought.

A few questions can guide that design:

  • What should the user see after a successful change?

  • Is the request complete, or has the external service only accepted it?

  • Can the user safely retry after an error?

  • Should their entered data remain available?

  • Which details belong in a user-facing message, and which belong in diagnostic records?

Retry behavior deserves special care. Retrying can be helpful when a temporary failure occurs, but it can also repeat a change that the service already processed. For operations such as creating a payment or submitting an order, duplicate requests can have real consequences. The integration design should account for this possibility, using the safeguards supported by the service and the application.

It also helps to avoid treating every error as the same event. If the service provides useful status information, the application can use it to choose a more relevant response. The goal isn’t to overwhelm a user with technical codes. It’s to offer enough context to make the next step clear.

A small pair of parameters, a better experience

OnSuccess and OnError are more than technical labels attached to an integration. They give Appian developers a way to connect system outcomes with sensible interface behavior. A clear confirmation can reassure someone that their change went through; a thoughtful error response can keep a temporary problem from turning into a dead end.

The strongest designs account for both outcomes from the start. They confirm what the system has actually done, protect users from accidental repeat actions, and explain what to do when a request fails. That attention to the moments around an integration call is what makes a data change feel smooth—not merely connected.