Complete Guidewire integration skill pack with 24 skills covering InsuranceSuite, PolicyCenter, ClaimCenter, and insurance platform development. Flagship tier vendor pack.

24 Skills

MIT License

Free Pricing

Installation

Open Claude Code and run this command:

/plugin install guidewire-pack@claude-code-plugins-plus

Use --global to install for all projects, or --project for current project only.

Skills (24)

guidewire-ci-integration SKILL.md View full skill →

Configure CI/CD pipelines for Guidewire with Gosu compilation, GUnit tests, and configuration deployment.

ReadWriteEditBash(curl:*)Bash(gradle:*)Grep

guidewire-common-errors SKILL.md View full skill →

Diagnose and fix common Guidewire Cloud API errors including Gosu exceptions, validation failures, and integration issues.

ReadWriteEditBash(curl:*)Bash(gradle:*)Grep

guidewire-core-workflow-a SKILL.md View full skill →

Execute Guidewire primary workflow: Policy lifecycle in PolicyCenter.

ReadWriteEditBash(curl:*)Grep

Guidewire Core Workflow A: Policy Lifecycle

Overview

The complete policy lifecycle in PolicyCenter: account creation, submission, quoting, binding, issuance, endorsements, and renewals via Cloud API.

Policy Lifecycle States


Account -> Submission -> Quote -> Bind -> Issue -> In-Force
                                                    |
                                          Endorse / Renew / Cancel

Instructions

Step 1: Create Account


const account = await fetch(`${GW_PC}/account/v1/accounts`, {
  method: 'POST', headers,
  body: JSON.stringify({
    data: { attributes: {
      accountHolderContact: {
        firstName: 'John', lastName: 'Smith',
        primaryAddress: { addressLine1: '123 Main St', city: 'Atlanta', state: 'GA', postalCode: '30301' },
        dateOfBirth: '1985-03-15',
      },
      producerCodes: [{ id: 'pc:100' }],
    }}
  }),
}).then(r => r.json());
console.log(`Account: ${account.data.attributes.accountNumber}`);

Step 2: Create Submission


const submission = await fetch(`${GW_PC}/job/v1/submissions`, {
  method: 'POST', headers,
  body: JSON.stringify({
    data: { attributes: {
      account: { id: account.data.id },
      baseState: 'GA', effectiveDate: '2025-04-01',
      product: { code: 'PersonalAuto' },
      producerCode: { id: 'pc:100' },
    }}
  }),
}).then(r => r.json());

Step 3: Quote -> Bind -> Issue


// Quote the submission
await fetch(`${GW_PC}/job/v1/submissions/${submission.data.id}/quote`, { method: 'POST', headers });

// Bind
await fetch(`${GW_PC}/job/v1/submissions/${submission.data.id}/bind`, { method: 'POST', headers });

// Issue
await fetch(`${GW_PC}/job/v1/submissions/${submission.data.id}/issue`, { method: 'POST', headers });
console.log('Policy issued successfully');

Error Handling

Error	Cause	Solution
`Cannot quote`	Missing coverages/vehicles	Add required data before quoting
`UW hold`	Underwriting referral	Process UW approval in PolicyCenter
`Rating error`	Rate table issue	Check product configuration

For detailed Gosu and API examples, see: implementation guide

Resources

PolicyCenter Cloud API

Next Steps

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

guidewire-core-workflow-b SKILL.md View full skill →

Execute Guidewire claims workflow in ClaimCenter: FNOL, investigation, reserves, and settlement.

ReadWriteEditBash(curl:*)Grep

guidewire-cost-tuning SKILL.md View full skill →

Optimize Guidewire Cloud costs: license management, API usage, compute right-sizing.

ReadWriteEditBash(curl:*)Bash(gradle:*)Grep

guidewire-data-handling SKILL.md View full skill →

Data handling for Guidewire: entity management, data migration, batch operations, and governance.

ReadWriteEditBash(curl:*)Bash(gradle:*)Grep

guidewire-debug-bundle SKILL.md View full skill →

Collect Guidewire diagnostic info including Cloud API responses, Gosu stack traces, and server logs.

ReadWriteEditBash(curl:*)Bash(gradle:*)Grep

guidewire-deploy-integration SKILL.md View full skill →

Deploy Guidewire integrations to Cloud Platform with configuration packages and release management.

ReadWriteEditBash(curl:*)Bash(gradle:*)Grep

guidewire-enterprise-rbac SKILL.md View full skill →

Implement Guidewire RBAC: API roles, user permissions, and security policies.

ReadWriteEditBash(curl:*)Bash(gradle:*)Grep

Guidewire Enterprise RBAC

Overview

Guidewire InsuranceSuite (PolicyCenter, ClaimCenter, BillingCenter) enforces role-based access at both the UI and Cloud API layers. Claims adjusters see only claims in their assigned regions. Underwriters access policy data scoped to their authority level. Admins manage user provisioning through Guidewire Cloud Console (GCC). Insurance regulations (NAIC, state DOI) require strict data classification tiers and audit trails on every policy and claim access. SAML assertions map AD groups to Guidewire roles for SSO.

Role Hierarchy

Role	Permissions	Scope
System Admin	User provisioning, role config, API token management via GCC	All modules
Underwriter	Create/bind policies, view risk data, approve endorsements	Authority-level tier
Claims Adjuster	View/update claims, upload documents, set reserves	Assigned region/LOB
Agent/Broker	Submit applications, view own policy status, limited billing	Own book of business
Auditor	Read-only access to all records, export compliance reports	Organization-wide

Permission Check


async function checkGuidewireAccess(userId: string, resource: string, action: 'read' | 'write'): Promise<boolean> {
  const response = await fetch(`${GW_CLOUD_API}/admin/v1/users/${userId}/permissions`, {
    headers: { Authorization: `Bearer ${GW_API_TOKEN}`, 'Content-Type': 'application/json' },
  });
  const perms = await response.json();
  const grant = perms.data.find((p: any) => p.resource === resource);
  if (!grant) return false;
  return action === 'read' ? grant.canRead : grant.canWrite;
}

Role Assignment


async function assignGuidewireRole(userId: string, role: string, region?: string): Promise<void> {
  await fetch(`${GW_CLOUD_API}/admin/v1/users/${userId}/roles`, {
    method: 'POST',
    headers: { Authorization: `Bearer ${GW_API_TOKEN}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ roleCode: role, regionFilter: region ?? 'ALL', effectiveDate: new Date().toISOString() }),
  });
}

async function revokeRole(userId: string, role: string): Promise<void> {
  await fetch(`${GW_CLOUD_API}/admin/v1/users/${userId}/roles/${role}`, {
    method: 'DELETE',
    headers: { Authorization: `Bearer ${GW_API_TOKEN}` },
  });
}

Audit Logging


interface GuidewireAuditEntry {
  timestamp: string; userId: string; role: string;
  action: 'policy_view' | 'claim_update' | 'reserve_set' | 'document_upload' | 'rol


                
                  
                  
                  guidewire-hello-world
                  SKILL.md
                  View full skill →
                
                
                  Execute first API calls to Guidewire PolicyCenter, ClaimCenter, and BillingCenter.
                  
                      ReadWriteEditBash(curl:*)Bash(npm:*)Grep
                    
                
                
                  Guidewire Hello World
Overview
Execute your first Cloud API calls to PolicyCenter, ClaimCenter, and BillingCenter. All Guidewire Cloud APIs are RESTful with JSON payloads and follow Swagger 2.0.
Instructions
Step 1: Query PolicyCenter Accounts

const token = await getGuidewireToken();
const headers = { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' };

// List accounts
const accounts = await fetch(`${process.env.GW_PC_URL}/account/v1/accounts?pageSize=5`, { headers });
const data = await accounts.json();
data.data.forEach((acct: any) => {
  console.log(`Account: ${acct.attributes.accountNumber} | ${acct.attributes.accountHolderContact.displayName}`);
});

Step 2: Query ClaimCenter Claims

// List recent claims
const claims = await fetch(`${process.env.GW_CC_URL}/claim/v1/claims?pageSize=5`, { headers });
const claimData = await claims.json();
claimData.data.forEach((claim: any) => {
  console.log(`Claim: ${claim.attributes.claimNumber} | ${claim.attributes.status.code} | ${claim.attributes.lossDate}`);
});

Step 3: Guidewire API Response Structure

{
  "count": 42,
  "data": [
    {
      "attributes": { "accountNumber": "A000001", "...": "..." },
      "checksum": "abc123",
      "links": { "self": { "href": "/account/v1/accounts/pc:123" } }
    }
  ],
  "links": { "next": { "href": "/account/v1/accounts?pageSize=5&offsetToken=..." } }
}

Key patterns: data[] array, attributes for fields, checksum for optimistic locking, links for pagination.
Error Handling

Error
Code
Solution


404 Not Found
Invalid endpoint path
Verify /account/v1/accounts format


400 Bad Request
Invalid query params
Check pageSize, filter syntax


422 Unprocessable
Business rule violation
Read userMessage in response


409 Conflict
Stale checksum
Re-GET resource, use new checksum


For detailed implementation, see: implementation guide
Resources

PolicyCenter API Reference
ClaimCenter API Reference

                
                  
                  
                  guidewire-incident-runbook
                  SKILL.md
                  View full skill →
                
                
                  Respond to Guidewire production incidents: triage, mitigation, and recovery.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Incident Runbook
Overview
Triage: Check GCC > Monitoring for system health. API errors -> check OAuth tokens and API roles. Batch failures -> review batch logs in GCC. Performance degradation -> check JVM metrics and query performance. Escalate to Guidewire Support with GCC ticket.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

                
                  
                  
                  guidewire-install-auth
                  SKILL.md
                  View full skill →
                
                
                  Install Guidewire Studio, configure Cloud API OAuth2 authentication, and register applications with Guidewire Hub.
                  
                      ReadWriteEditBash(java:*)Bash(gradle:*)Bash(curl:*)Grep
                    
                
                
                  Guidewire Install & Auth
Overview
Set up Guidewire InsuranceSuite development: install Guidewire Studio (IntelliJ-based), configure Cloud API OAuth2 authentication via Guidewire Hub, and obtain JWT tokens for PolicyCenter, ClaimCenter, and BillingCenter APIs.
Prerequisites

JDK 17 (Guidewire Cloud 202503+)
Gradle 8.x
Guidewire Cloud Console (GCC) access at https://gcc.guidewire.com

Instructions
Step 1: Register Application in Guidewire Hub

GCC > Identity & Access > Applications > Register Application

Service Application (backend): OAuth2 Client Credentials flow
Browser Application (Jutro): OAuth2 Authorization Code flow

Record: client_id and client_secret

Step 2: Configure OAuth2 Environment

# .env (NEVER commit)
GW_AUTH_URL=https://guidewire-hub.guidewire.com/oauth/token
GW_CLIENT_ID=your_client_id
GW_CLIENT_SECRET=your_client_secret
GW_PC_URL=https://your-tenant.guidewire.com/pc/rest
GW_CC_URL=https://your-tenant.guidewire.com/cc/rest
GW_BC_URL=https://your-tenant.guidewire.com/bc/rest

Step 3: Obtain Access Token

async function getGuidewireToken(): Promise<string> {
  const res = await fetch(process.env.GW_AUTH_URL!, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: process.env.GW_CLIENT_ID!,
      client_secret: process.env.GW_CLIENT_SECRET!,
      scope: 'pc.service cc.service bc.service',
    }),
  });
  const { access_token } = await res.json();
  return access_token;
}

Step 4: Verify Connection

TOKEN=$(curl -s -X POST "$GW_AUTH_URL" \
  -d "grant_type=client_credentials&client_id=$GW_CLIENT_ID&client_secret=$GW_CLIENT_SECRET" \
  | jq -r '.access_token')

curl -s -H "Authorization: Bearer $TOKEN" \
  "$GW_PC_URL/account/v1/accounts?pageSize=1" | jq '.count'

Error Handling

Error
Cause
Solution


invalid_client
Wrong credentials
Verify client_id/secret in GCC


invalid_scope
Unauthorized scope
Check API role assignments


401 Unauthorized
Expired token
Refresh (tokens are short-lived)


403 Forbidden
Missing API role
Assign roles in GCC > Identity & Access


PKIX path building failed
SSL cert issue
Import Guidewire CA certificates


For detailed implementation, see: 
                

              

                
                  
                  
                  guidewire-local-dev-loop
                  SKILL.md
                  View full skill →
                
                
                  Configure Guidewire Studio local development with Gosu debugging, hot reload, and test data.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Local Dev Loop
Overview
Guidewire Studio (IntelliJ-based): Gosu debugging with breakpoints, hot deploy of Gosu changes, GUnit tests, local test data via sample data loader. Use gradle runServer for local InsuranceSuite instance.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

                
                  
                  
                  guidewire-migration-deep-dive
                  SKILL.md
                  View full skill →
                
                
                  Migrate to Guidewire Cloud from self-managed or legacy insurance systems.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Migration Deep Dive
Overview
Migration phases: 1) Assessment (current system audit), 2) Configuration (product model, rules), 3) Data migration (policies, claims, accounts via ETL), 4) Integration cutover (API endpoints, event consumers), 5) UAT and go-live. Use Guidewire Cloud Migration Accelerator.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

                
                  
                  
                  guidewire-multi-env-setup
                  SKILL.md
                  View full skill →
                
                
                  Configure Guidewire multi-environment: dev, staging, and production with configuration promotion.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Multi Env Setup
Overview
GCC manages environments: dev (rapid iteration), staging (UAT), production. Configuration promotion via GCC pipeline. Environment-specific OAuth credentials. Separate integration gateway endpoints per environment. Data isolation enforced by GCC.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

                
                  
                  
                  guidewire-observability
                  SKILL.md
                  View full skill →
                
                
                  Monitor Guidewire InsuranceSuite: logging, metrics, tracing, and alerting via GCC.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Observability
Overview
Guidewire InsuranceSuite processes claims, policies, and billing through long-running batch jobs and synchronous Cloud APIs. Observability must track claim processing times, policy synchronization health, billing accuracy, and integration endpoint status. Batch failures in ClaimCenter or PolicyCenter can silently block downstream workflows, so real-time alerting on queue depth and job completion is critical for insurance operations SLAs.
Key Metrics

Metric
Type
Target
Alert Threshold


Claim processing time
Histogram
< 30s
> 60s


Policy sync success rate
Gauge
> 99.5%
< 98%


Billing accuracy rate
Gauge
> 99.9%
< 99.5%


Cloud API latency p95
Histogram
< 500ms
> 2s


Batch job completion rate
Gauge
100%
< 95% per cycle


Integration queue depth
Gauge
< 100
> 500


Instrumentation

async function trackGuidewireAPI(endpoint: string, operation: string, fn: () => Promise<any>) {
  const start = Date.now();
  try {
    const result = await fn();
    metrics.histogram('guidewire.api.latency', Date.now() - start, { endpoint, operation });
    metrics.increment('guidewire.api.calls', { endpoint, status: 'ok' });
    return result;
  } catch (err) {
    metrics.increment('guidewire.api.errors', { endpoint, status: err.statusCode });
    throw err;
  }
}

Health Check Dashboard

async function guidewireHealth(): Promise<Record<string, string>> {
  const batchStatus = await gccAdmin.getBatchJobStatus();
  const apiLatency = await metrics.query('guidewire.api.latency', 'p95', '5m');
  const queueDepth = await gccAdmin.getIntegrationQueueDepth();
  return {
    batch_jobs: batchStatus.allCompleted ? 'healthy' : 'failed',
    api_latency: apiLatency < 500 ? 'healthy' : 'slow',
    integration_queue: queueDepth < 100 ? 'healthy' : 'backlogged',
  };
}

Alerting Rules

const alerts = [
  { metric: 'guidewire.claim.processing_time_p95', condition: '> 60s', window: '15m', severity: 'warning' },
  { metric: 'guidewire.batch.completion_rate', condition: '< 0.95', window: '1h', severity: 'critical' },
  { metric: 'guidewire.integration.queue_depth', condition: '> 500', window: '10m', severity: 'critical' },
  { metric: 'guidewire.api.error_rate', conditio

                

              

                
                  
                  
                  guidewire-performance-tuning
                  SKILL.md
                  View full skill →
                
                
                  Optimize Guidewire performance: Gosu query optimization, batch processing, caching, and JVM tuning.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Performance Tuning
Overview
Optimize Gosu queries: use Query API with proper filters (avoid loading all entities), batch processing with BatchProcessBase, cache frequently accessed reference data, tune JVM heap via GCC. Monitor via GCC > Performance dashboard.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

                
                  
                  
                  guidewire-prod-checklist
                  SKILL.md
                  View full skill →
                
                
                  Production deployment readiness for Guidewire Cloud including configuration promotion and testing.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Prod Checklist
Overview
Verify: all Gosu compiles without errors, GUnit tests pass, Cloud API roles configured, integration gateway endpoints tested, batch processes scheduled, monitoring alerts configured, configuration promoted through dev > staging > production via GCC.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

                
                  
                  
                  guidewire-rate-limits
                  SKILL.md
                  View full skill →
                
                
                  Manage Guidewire Cloud API rate limits, quotas, and throttling for high-volume integrations.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Rate Limits
Overview
Cloud API enforces per-tenant rate limits. Batch operations use the batch API endpoint. Implement exponential backoff on 429 responses. Use API Gateway throttling in GCC. Optimize with bulk endpoints for batch processing.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

                
                  
                  
                  guidewire-reference-architecture
                  SKILL.md
                  View full skill →
                
                
                  Enterprise reference architecture for Guidewire InsuranceSuite Cloud deployments.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Reference Architecture
Overview
Architecture: Jutro Frontend -> Cloud API Gateway -> PolicyCenter/ClaimCenter/BillingCenter -> Integration Gateway -> External Systems. Data warehouse via Guidewire DataHub. Analytics via Guidewire Explore. All managed in GCC.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

                
                  
                  
                  guidewire-sdk-patterns
                  SKILL.md
                  View full skill →
                
                
                  Master Guidewire SDK patterns: REST API Client, Jutro Digital SDK, and Gosu best practices.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire SDK Patterns
Overview
Production-ready patterns for Guidewire insurance platform integration. Guidewire exposes both REST (Cloud API) and SOAP (legacy PolicyCenter/ClaimCenter) endpoints. The Cloud API uses JSON over REST for modern integrations while legacy on-prem requires SOAP/XML with WS-Security. A structured client abstracts this hybrid, providing consistent error handling and typed responses across both surfaces.
Singleton Client

let _client: GuidewireClient | null = null;
export function getClient(): GuidewireClient {
  if (!_client) {
    const key = process.env.GUIDEWIRE_API_KEY, base = process.env.GUIDEWIRE_BASE_URL;
    if (!key || !base) throw new Error('GUIDEWIRE_API_KEY and GUIDEWIRE_BASE_URL must be set');
    _client = new GuidewireClient(base, key);
  }
  return _client;
}
class GuidewireClient {
  private h: Record<string, string>;
  constructor(private base: string, key: string) {
    this.h = { 'Authorization': `Bearer ${key}`, 'Content-Type': 'application/json' };
  }
  async getPolicies(filter?: string): Promise<GWPolicy[]> {
    const url = `${this.base}/pc/rest/common/v1/policies${filter ? `?filter=${encodeURIComponent(filter)}` : ''}`;
    const r = await fetch(url, { headers: this.h });
    if (!r.ok) throw new GWError(r.status, await r.text()); return (await r.json()).data;
  }
  async getClaims(policyId: string): Promise<GWClaim[]> {
    const r = await fetch(`${this.base}/cc/rest/common/v1/claims?policyId=${policyId}`, { headers: this.h });
    if (!r.ok) throw new GWError(r.status, await r.text()); return (await r.json()).data;
  }
  async createClaim(payload: Partial<GWClaim>): Promise<GWClaim> {
    const r = await fetch(`${this.base}/cc/rest/common/v1/claims`, {
      method: 'POST', headers: this.h, body: JSON.stringify({ data: { attributes: payload } }) });
    if (!r.ok) throw new GWError(r.status, await r.text()); return (await r.json()).data;
  }
}

Error Wrapper

export class GWError extends Error {
  constructor(public status: number, message: string) { super(message); this.name = 'GWError'; }
}
export async function safeCall<T>(op: string, fn: () => Promise<T>): Promise<T> {
  try { return await fn(); }
  catch (e: any) {
    if (e instanceof GWError && e.status === 429) { await new Promise(r => setTimeout(r, 5000)); return fn(); }
    if (e instanceof GWError && e.status === 401) throw new GWError(401, 'Invalid GUIDEWIRE_API_KEY');
    if (e instanceof GWError && e.status === 409) throw new GWError(409, `${op}: entity conflict`);
    throw new GWError(e.status ?? 0, `${op} failed: ${e.message}`);
  }
}

Request Builder

class GWQuery {
  private f: string[] = []; private inc: s

                

              

                
                  
                  
                  guidewire-security-basics
                  SKILL.md
                  View full skill →
                
                
                  Implement Guidewire security: OAuth2 JWT, API roles, Gosu secure coding, and data protection.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Security Basics
Overview
Guidewire manages insurance policy administration, claims processing, and billing containing policyholder PII (SSNs, driver's license numbers, medical records for claims), financial settlement data, and adjuster notes. A breach exposes claimant personal information, policy terms, and payment histories across the entire insurance book of business. Secure OAuth2 JWT tokens, Cloud API roles, Gosu custom code, and any integration touching policy or claims data.
API Key Management

function createGuidewireClient(): { token: string; baseUrl: string } {
  const clientId = process.env.GUIDEWIRE_CLIENT_ID;
  const clientSecret = process.env.GUIDEWIRE_CLIENT_SECRET;
  const tokenUrl = process.env.GUIDEWIRE_TOKEN_URL;
  if (!clientId || !clientSecret || !tokenUrl) {
    throw new Error("Missing GUIDEWIRE_CLIENT_ID, CLIENT_SECRET, or TOKEN_URL");
  }
  // OAuth2 tokens are short-lived JWTs — never cache beyond expiry
  console.log("Guidewire OAuth2 client initialized for:", tokenUrl);
  return { token: "", baseUrl: process.env.GUIDEWIRE_API_URL! };
}

Webhook Signature Verification

import crypto from "crypto";
import { Request, Response, NextFunction } from "express";

function verifyGuidewireWebhook(req: Request, res: Response, next: NextFunction): void {
  const signature = req.headers["x-guidewire-signature"] as string;
  const secret = process.env.GUIDEWIRE_WEBHOOK_SECRET!;
  const expected = crypto.createHmac("sha256", secret).update(req.body).digest("hex");
  if (!signature || !crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
    res.status(401).send("Invalid signature");
    return;
  }
  next();
}

Input Validation

import { z } from "zod";

const ClaimSchema = z.object({
  claim_number: z.string().regex(/^CLM-\d{8,12}$/),
  policy_number: z.string().regex(/^POL-\d{8,12}$/),
  claimant_id: z.string().uuid(),
  loss_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
  loss_type: z.enum(["auto", "property", "liability", "workers_comp", "medical"]),
  reserve_amount: z.number().nonnegative().max(10_000_000),
});

function validateClaimData(data: unknown) {
  return ClaimSchema.parse(data);
}

Data Protection

const GUIDEWIRE_PII_FIELDS = ["ssn", "drivers_license", "medical_records", "bank_account", "claimant_dob", "adjuster_notes"];

function redactGuidewireLog(record: Record<string, unknown>): Record<string, unknown> {
  const redacted = { ...record };
  for (const field of GUIDEWIRE_PII_FIELDS) {
    if (field in redacted) redacted[field] = "

                

              

                
                  
                  
                  guidewire-upgrade-migration
                  SKILL.md
                  View full skill →
                
                
                  Upgrade Guidewire InsuranceSuite versions and migrate between Cloud environments.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Upgrade Migration
Overview
Version upgrade: review release notes for breaking changes, run upgrade tool in Studio, merge configuration changes, test all Gosu customizations, validate API compatibility, promote through environments. Use GCC for cloud version management.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

                
                  
                  
                  guidewire-webhooks-events
                  SKILL.md
                  View full skill →
                
                
                  Implement Guidewire App Events and webhook integrations for event-driven architecture.
                  
                      ReadWriteEditBash(curl:*)Bash(gradle:*)Grep
                    
                
                
                  Guidewire Webhooks Events
Overview
Guidewire App Events: configure outbound events in GCC for entity changes (claim created, policy issued). Events published to message queue (AWS SQS/SNS). Build event consumers that process InsuranceSuite state changes in near-real-time.
For detailed implementation, see: implementation guide
Resources

Guidewire Developer Portal
Cloud API Reference
Guidewire Cloud Console
Gosu Language Guide

                
              

          

        


      
      

      
      

      
      

      
      
  Ready to use guidewire-pack?
  
    
    
  




      
      
          Related Plugins
          
            
                maintainx-pack
                Complete MaintainX integration skill pack with 24 skills covering work orders, preventive maintenance, asset management, and CMMS workflows. Flagship tier vendor pack.
              
          
        

      
      
          Tags
          
            guidewireinsurancepolicycenterclaimcenterbillingcenterinsurancesuiteenterprise

Error	Cause	Solution
`Policy not found`	Invalid policy number	Verify policy exists and is in-force
`Reserve exceeds limit`	Authority level exceeded	Escalate to supervisor approval
`Payment validation`	Missing payee info	Add contact details before payment

Error	Code	Solution
`404 Not Found`	Invalid endpoint path	Verify `/account/v1/accounts` format
`400 Bad Request`	Invalid query params	Check `pageSize`, `filter` syntax
`422 Unprocessable`	Business rule violation	Read `userMessage` in response
`409 Conflict`	Stale checksum	Re-GET resource, use new checksum

Error	Cause	Solution
`invalid_client`	Wrong credentials	Verify client_id/secret in GCC
`invalid_scope`	Unauthorized scope	Check API role assignments
`401 Unauthorized`	Expired token	Refresh (tokens are short-lived)
`403 Forbidden`	Missing API role	Assign roles in GCC > Identity & Access
`PKIX path building failed`	SSL cert issue	Import Guidewire CA certificates

Metric	Type	Target	Alert Threshold
Claim processing time	Histogram	< 30s	> 60s
Policy sync success rate	Gauge	> 99.5%	< 98%
Billing accuracy rate	Gauge	> 99.9%	< 99.5%
Cloud API latency p95	Histogram	< 500ms	> 2s
Batch job completion rate	Gauge	100%	< 95% per cycle
Integration queue depth	Gauge	< 100	> 500

guidewire-pack

Installation

Skills (24)

Guidewire Ci Integration

Overview

Resources

Guidewire Common Errors

Overview

Resources

Guidewire Core Workflow A: Policy Lifecycle

Overview

Policy Lifecycle States

Instructions

Step 1: Create Account

Step 2: Create Submission

Step 3: Quote -> Bind -> Issue

Error Handling

Resources

Next Steps

Guidewire Core Workflow B: Claims Processing

Overview

Claims Lifecycle

Instructions

Step 1: Create Claim (FNOL)

Step 2: Set Reserves

Step 3: Create Payment

Error Handling

Resources

Next Steps

Guidewire Cost Tuning

Overview

Resources

Guidewire Data Handling

Overview

Resources

Guidewire Debug Bundle

Overview

Resources

Guidewire Deploy Integration

Overview

Resources

Guidewire Enterprise RBAC

Overview

Role Hierarchy

Permission Check

Role Assignment

Audit Logging

Guidewire Hello World

Overview

Instructions

Step 1: Query PolicyCenter Accounts

Step 2: Query ClaimCenter Claims

Step 3: Guidewire API Response Structure

Error Handling

Resources

Guidewire Incident Runbook

Overview

Resources

Guidewire Install & Auth

Overview

Prerequisites

Instructions

Step 1: Register Application in Guidewire Hub

Step 2: Configure OAuth2 Environment

Step 3: Obtain Access Token

Step 4: Verify Connection

Error Handling

Guidewire Local Dev Loop

Overview

Resources

Guidewire Migration Deep Dive

Overview

Resources

Guidewire Multi Env Setup

Overview

Resources

Guidewire Observability

Overview

Key Metrics

Instrumentation