Guidewire Core Workflow A

Guidewire Core Workflow A: Policy Lifecycle

Overview

Master the complete policy lifecycle in PolicyCenter: submission creation, quoting, binding, issuance, endorsements, and renewals.

Prerequisites

• Completed guidewire-install-auth and guidewire-sdk-patterns
• Understanding of P&C insurance concepts
• Valid API credentials with policy admin permissions

Policy Lifecycle States

Submission → Quote → Bind → Issue → In-Force → Endorsement/Renewal/Cancellation
    |           |       |      |          |
    v           v       v      v          v
 [Draft]    [Quoted] [Bound] [Issued] [Active Policy]

Instructions

Step 1: Create Account

// Create an account before policy submission
interface CreateAccountRequest {
  data: {
    attributes: {
      accountHolder: {
        contactSubtype: 'Person';
        firstName: string;
        lastName: string;
        dateOfBirth: string;
        primaryAddress: {
          addressLine1: string;
          city: string;
          state: { code: string };
          postalCode: string;
          country: { code: string };
        };
      };
      producerCodes: Array<{ id: string }>;
    };
  };
}

async function createAccount(holder: AccountHolderData): Promise<Account> {
  const request: CreateAccountRequest = {
    data: {
      attributes: {
        accountHolder: {
          contactSubtype: 'Person',
          firstName: holder.firstName,
          lastName: holder.lastName,
          dateOfBirth: holder.dateOfBirth,
          primaryAddress: {
            addressLine1: holder.address,
            city: holder.city,
            state: { code: holder.state },
            postalCode: holder.zip,
            country: { code: 'US' }
          }
        },
        producerCodes: [{ id: holder.producerCodeId }]
      }
    }
  };

  const response = await client.request<{ data: Account }>(
    'POST',
    '/account/v1/accounts',
    request
  );

  return response.data;
}

Step 2: Create Submission

// Create a new policy submission
interface CreateSubmissionRequest {
  data: {
    attributes: {
      account: { id: string };
      baseState: { code: string };
      effectiveDate: string;
      product: { code: string };
      producerCode: { id: string };
      jobType: { code: 'Submission' };
    };
  };
}

async function createSubmission(
  accountId: string,
  effectiveDate: string,
  productCode: string = 'PersonalAuto'
): Promise<Submission> {
  const request: CreateSubmissionRequest = {
    data: {
      attributes: {
        account: { id: accountId },
        baseState: { code: 'CA' },
        effectiveDate: effectiveDate,
        product: { code: productCode },
        producerCode: { id: 'pc:DefaultProducerCode' },
        jobType: { code: 'Submission' }
      }
    }
  };

  const response = await client.request<{ data: Submission }>(
    'POST',
    '/job/v1/submissions',
    request
  );

  console.log(`Created submission: ${response.data.jobNumber}`);
  return response.data;
}

Step 3: Add Policy Lines and Coverages

// Add Personal Auto line with vehicles and coverages
interface VehicleData {
  vin: string;
  year: number;
  make: string;
  model: string;
  costNew: number;
}

async function addVehicleWithCoverages(
  submissionId: string,
  policyPeriodId: string,
  vehicle: VehicleData
): Promise<void> {
  // Add vehicle
  const vehicleRequest = {
    data: {
      attributes: {
        vin: vehicle.vin,
        year: vehicle.year,
        make: vehicle.make,
        model: vehicle.model,
        costNew: { amount: vehicle.costNew, currency: 'usd' },
        vehicleType: { code: 'PP' } // Private Passenger
      }
    }
  };

  const vehicleResponse = await client.request(
    'POST',
    `/job/v1/submissions/${submissionId}/policy-periods/${policyPeriodId}/vehicles`,
    vehicleRequest
  );

  const vehicleId = vehicleResponse.data.id;

  // Add coverages to vehicle
  const coverages = [
    { code: 'PALiabilityCov', limits: { BI: '100000/300000', PD: '50000' } },
    { code: 'PACollisionCov', deductible: 500 },
    { code: 'PAComprehensiveCov', deductible: 250 },
    { code: 'PAMedPayCov', limit: 5000 }
  ];

  for (const coverage of coverages) {
    await client.request(
      'POST',
      `/job/v1/submissions/${submissionId}/policy-periods/${policyPeriodId}/vehicles/${vehicleId}/coverages`,
      {
        data: {
          attributes: {
            patternCode: coverage.code,
            // Coverage-specific terms would be set here
          }
        }
      }
    );
  }
}

Step 4: Add Drivers

// Add drivers to policy
interface DriverData {
  firstName: string;
  lastName: string;
  dateOfBirth: string;
  licenseNumber: string;
  licenseState: string;
}

async function addDriver(
  submissionId: string,
  policyPeriodId: string,
  driver: DriverData
): Promise<PolicyDriver> {
  const request = {
    data: {
      attributes: {
        firstName: driver.firstName,
        lastName: driver.lastName,
        dateOfBirth: driver.dateOfBirth,
        licenseNumber: driver.licenseNumber,
        licenseState: { code: driver.licenseState },
        gender: { code: 'M' },
        maritalStatus: { code: 'S' }
      }
    }
  };

  const response = await client.request<{ data: PolicyDriver }>(
    'POST',
    `/job/v1/submissions/${submissionId}/policy-periods/${policyPeriodId}/drivers`,
    request
  );

  return response.data;
}

Step 5: Quote the Submission

// Request a quote
async function quoteSubmission(submissionId: string): Promise<QuoteResult> {
  // Trigger quote calculation
  const quoteResponse = await client.request<{ data: Submission }>(
    'POST',
    `/job/v1/submissions/${submissionId}/quote`,
    {}
  );

  // Get quote details
  const submission = quoteResponse.data;
  const policyPeriod = await client.request<{ data: PolicyPeriod }>(
    'GET',
    `/job/v1/submissions/${submissionId}/policy-periods/${submission.latestPeriod.id}`
  );

  return {
    jobNumber: submission.jobNumber,
    status: submission.status.code,
    totalPremium: policyPeriod.data.totalPremium,
    taxes: policyPeriod.data.taxes,
    effectiveDate: policyPeriod.data.effectiveDate,
    expirationDate: policyPeriod.data.expirationDate
  };
}

Step 6: Bind the Policy

// Bind the quoted submission
async function bindSubmission(submissionId: string): Promise<BoundPolicy> {
  const response = await client.request<{ data: Submission }>(
    'POST',
    `/job/v1/submissions/${submissionId}/bind`,
    {}
  );

  if (response.data.status.code !== 'Bound') {
    throw new Error(`Bind failed: ${response.data.status.name}`);
  }

  return {
    jobNumber: response.data.jobNumber,
    policyNumber: response.data.policy.policyNumber,
    status: 'Bound'
  };
}

Step 7: Issue the Policy

// Issue bound policy (often automatic)
async function issuePolicy(submissionId: string): Promise<IssuedPolicy> {
  const response = await client.request<{ data: Submission }>(
    'POST',
    `/job/v1/submissions/${submissionId}/issue`,
    {}
  );

  return {
    policyNumber: response.data.policy.policyNumber,
    status: 'Issued',
    effectiveDate: response.data.latestPeriod.effectiveDate
  };
}

Gosu Implementation

// Complete policy submission workflow in Gosu
package gw.custom.submission

uses gw.api.productmodel.Product
uses gw.api.util.Logger
uses gw.transaction.Transaction

class SubmissionWorkflow {
  private static final var LOG = Logger.forCategory("SubmissionWorkflow")

  static function createAndQuoteSubmission(
    account : Account,
    product : Product,
    effectiveDate : Date
  ) : Submission {

    return Transaction.runWithNewBundle(\bundle -> {
      var account = bundle.add(account)

      // Create submission
      var submission = new Submission(bundle)
      submission.Account = account
      submission.Product = product
      submission.EffectiveDate = effectiveDate
      submission.ProducerCodeOfRecord = account.ProducerCodes.first()

      // Initialize policy period
      submission.initializePeriod()
      var period = submission.LatestPeriod

      // Add line of business
      if (product.Code == "PersonalAuto") {
        initializePersonalAutoLine(period)
      }

      LOG.info("Created submission: ${submission.JobNumber}")
      return submission
    })
  }

  private static function initializePersonalAutoLine(period : PolicyPeriod) {
    var paLine = new PersonalAutoLine(period.Bundle)
    paLine.PolicyPeriod = period

    // Set state-specific coverages
    paLine.initializeCoverages()
  }

  static function quoteSubmission(submission : Submission) : PolicyPeriod {
    return Transaction.runWithNewBundle(\bundle -> {
      var sub = bundle.add(submission)

      // Validate before quoting
      var validationResult = sub.LatestPeriod.validateForQuote()
      if (validationResult.hasErrors()) {
        throw new ValidationException(validationResult.AllMessages.join(", "))
      }

      // Request quote
      sub.requestQuote()

      // Wait for async rating if needed
      if (sub.LatestPeriod.Status == PolicyPeriodStatus.TC_QUOTING) {
        sub.LatestPeriod.awaitQuoteComplete()
      }

      LOG.info("Quoted submission ${sub.JobNumber}: ${sub.LatestPeriod.TotalPremiumRPT}")
      return sub.LatestPeriod
    })
  }

  static function bindAndIssue(submission : Submission) : Policy {
    return Transaction.runWithNewBundle(\bundle -> {
      var sub = bundle.add(submission)

      // Bind
      sub.requestBind()
      if (!sub.LatestPeriod.canIssue()) {
        throw new IllegalStateException("Cannot issue: ${sub.LatestPeriod.Status}")
      }

      // Issue
      sub.requestIssue()

      LOG.info("Issued policy: ${sub.Policy.PolicyNumber}")
      return sub.Policy
    })
  }
}

Output

• Created account with account holder details
• Submission with unique job number
• Quote with premium breakdown
• Bound and issued policy with policy number

Error Handling

Common Validation Issues

// Handle validation errors
interface ValidationError {
  field: string;
  message: string;
  code: string;
}

function handleValidationErrors(errors: ValidationError[]): void {
  const grouped = errors.reduce((acc, err) => {
    acc[err.field] = acc[err.field] || [];
    acc[err.field].push(err.message);
    return acc;
  }, {} as Record<string, string[]>);

  console.log('Validation Errors:');
  Object.entries(grouped).forEach(([field, messages]) => {
    console.log(`  ${field}:`);
    messages.forEach(msg => console.log(`    - ${msg}`));
  });
}

Resources

• PolicyCenter Cloud API
• Submission Workflow Guide
• Policy Lifecycle Documentation

Next Steps

For claims processing workflow, see guidewire-core-workflow-b.