Policy Continuations (Beta)

Policy continuations accommodate policy changes by creating a new policy based on existing policy data. The existing policy is called a continued policy, and the new policy is called a continuation policy.

Continuation policies can be based on a different product type and can use data structures that the existing product type cannot support. Policy continuations are useful when a normal policy change can't be made or can't be made safely.

Continuation quotes are constructed using the Continuation Plugin, which become continuation policies when issued.

Use Cases

The policy continuations feature is designed to support the following use cases:

• Cancelling and rewriting a policy
• Transferring a policy between accounts
• Upgrading a policy from one product to another
• Flat cancellation
• Updating immutable policy data such as timezone and duration basis

Configuration

Each ProductRef configuration object contains a continuationFor property, which specifies the product as the continuation for one or more products.

The following configuration example specifies the StandardAuto product as the continuation for the PersonalAuto and CommercialAuto products:

{
	"products": {
		"StandardAuto": {
			"continuationFor": ["PersonalAuto", "CommercialAuto"]
		}
	}
}

Execution

Once your configuration changes have been deployed, create a policy transaction for your target policy with a transactionCategory of continuation and an optional continuation change instruction.

The Continuation Plugin will construct a new continuation quote when the transaction is validated. Once the transaction successfully moves to the validated lifecycle state, your continuation quote will be created in the draft state.

Because policy continuations are similar to cancellations, the Cancellation Plugin will be executed when the transaction is priced to allow for the modification of return premiums or similar pricing modifications. Cancellation Plugin implementations may need to be modified to avoid unexpected consequences of policy continuations. For example, retention charges probably shouldn't be created when executing a policy continuation.

Issue the transaction, then issue the quote to create your new continuation policy. The quote cannot be issued until the transaction is issued.

Multiple continuation transactions can be created for the same policy, but only one can be issued, which will cause all others to move to the invalidated state.

The continuedByLocator property on the continued policy will be set to the locator of the continuation quote when the transaction is issued, and the continuationOfLocator property on the continuation quote will be set to the locator of the continued policy when the continuation quote is created. The continuationOfLocator property will remain unchanged and will be copied to the continuation policy when the continuation quote is issued.

The continued policy status will be added to the continued policy when the transaction is issued, and the continuation policy status will be added to the continuation policy when the continuation policy is created.

The only transactions allowed for continued policies are reversal, cancellation, and flat-cancellation.

Continuation Plugin

The Continuation Plugin constructs a new continuation quote when the transaction is validated. Once the transaction successfully moves to the validated lifecycle state, your continuation quote will be created in the draft state.

Policy continuations cannot be executed unless the relevant Continuation Plugin method is implemented.

Implementation

Create a new Java class in the src/main/java/com/socotra/deployment/customer folder. All plugin code must be contained within this folder. We named our class ContinuationPluginImpl.java in the example below, but you can name your class whatever you'd like.

Implement the ContinuationPlugin interface, and override the method corresponding to the products involved in your policy continuation.

For example, the following class contains a method that continues policies using the CommercialAuto product by creating a new continuation quote using the StandardAuto product:

public class ContinuationPluginImpl implements ContinuationPlugin {
    private static final Logger log = LoggerFactory.getLogger(ContinuationPluginImpl.class);

    @Override
    public StandardAutoResponse quoteContinuation(ContinuationPlugin.CommercialAutoToStandardAutoRequest request) {

        // Update and return this quote template
        StandardAutoQuote quote = request.quoteTemplate();

        List<VehicleQuote> updatedVehicles = quote.vehicles().stream()
                .map(vehicle -> vehicle.toBuilder()
                        .data(vehicle.data().toBuilder()
                                .vehicleYear(2024) // Update value
                                .build())
                        .build())
                .toList();

        // Copy from CommercialAuto data extension
        String lastName = request.segment().data().driver().lastName();

        StandardAutoQuote updatedQuote = quote.toBuilder()
                .data(quote.data().toBuilder()
                        .driver(Driver.builder()
                                .lastName(lastName)
                                .yearsOfExperience(4) // This field only exists in StandardAuto
                                .build())
                        .build())
                .vehicles(updatedVehicles)
                .build();

        Map<String, Object> data = new HashMap<>();
        data.put("applicationNumber", String.valueOf(new Random().nextInt(900) + 100));

        // Update static data
        StandardAutoQuoteStaticData staticData =
                StandardAutoQuoteStaticData.builder()
                        .applicationNumber((String) data.get("applicationNumber"))
                        .build();

        return new StandardAutoResponse(updatedQuote, staticData, null);
    }
}

You can also execute a policy continuation from one product to the same product.

For example, the following class contains a method that continues policies using the StandardAuto product by creating a new continuation quote using the StandardAuto product:

public class ContinuationPluginImpl implements ContinuationPlugin {
    private static final Logger log = LoggerFactory.getLogger(ContinuationPluginImpl.class);

    @Override
    public StandardAutoResponse quoteContinuation(ContinuationPlugin.StandardAutoToStandardAutoRequest request) {

        // Update and return this quote template
        StandardAutoQuote quote = request.quoteTemplate();

        List<VehicleQuote> updatedVehicles = quote.vehicles().stream()
                .map(vehicle -> vehicle.toBuilder()
                        .data(vehicle.data().toBuilder()
                                .usage("Commercial")  // Data extension scoped to Q
                                .build())
                        .build())
                .toList();

        StandardAutoQuote updatedQuote = quote.toBuilder()
                .data(quote.data().toBuilder()
                        .region("West") // Data extension scoped to Q
                        .build())
                .vehicles(updatedVehicles)
                .build();

        Map<String, Object> data = new HashMap<>();
        data.put("applicationNumber", String.valueOf(new Random().nextInt(900) + 100));

        // Update static data
        StandardAutoQuoteStaticData staticData =
                StandardAutoQuoteStaticData.builder()
                        .applicationNumber((String) data.get("applicationNumber"))
                        .build();

        return new StandardAutoResponse(updatedQuote, staticData, null);
    }
}

The method request object contains the following properties:

• quoteTemplate - The new quote to be updated and returned
• segment - The segment created by applying the continuation policy transaction changes to the segment that takes effect when the transaction's effective time is reached
• term - The term
• policy - The policy

The method returns a response object that contains the new continuation quote. The response object can also contain updated static data.

Policy Data

By default, the policyNumber and effectiveTime remains the same after a policy continuation, but both can be overridden through a transaction change instruction or through the Continuation Plugin.

The endTime is automatically calculated based on the product's default duration, but it can also be overridden through the Continuation Plugin.

The accountLocator can be updated via any of the following approaches:

• Through an accountLocator change instruction
• Through the Continuation Plugin
• By modifying the continuation quote after it's created

Term Numbering

By default, the starting term number for a continuation policy will be set to the term number of the existing term + 1. The existing term refers to the term that has a startTime before the effectiveTime of the continuation transaction and an endTime equal to or after the effectiveTime of the continuation transaction.

The starting term number can be overridden through the continueWithTermNumber property in continuation change instructions.

By default, the startWithTermNumber property for each quote is set to the continueWithTermNumber for continuation policies and 0 for all other policies.

The continueWithTermNumber value is passed into the Continuation Plugin as startWithTermNumber, which can be accessed from the quoteTemplate property in the method request object. You can override this value from the Continuation Plugin.

API Endpoints

The Fetch Policy Continuation Data API endpoint can be used to retrieve data about previous terms for continuation policies. Superseded terms or segments will not be returned by this API endpoint.

Resets and Reversals

If a continuation transaction is reset, the continuation quote will be invalidated.

If a continuation transaction is reversed, the continuation quote will be invalidated if it has not yet been issued, and the continuation policy will be flat-cancelled if the quote has already been issued.

Continuations can be reversed by issuing a continuation policy reversal transaction for the continued policy. This will also invalidate the quote if it has not yet been issued and flat-cancel the continuation policy if the quote has been issued.

Cancellation

The cancelled policy status will not be added to the continued policy when a continuation policy is cancelled.

Out-of-Sequence Transactions

Cancellation transactions are the only out-of-sequence transactions allowed for continued policies.

Out-of-sequence continuation transactions are handled the same way as any other out-of-sequence transaction. See the Out-of-Sequence Transactions feature guide for more information.

See Also

• Policy Transactions
• ContinuationChangeInstructionRequest
• Policies API