Discover the Secrets Behind a CoreCONNECT Deployment
— Read Path —
Systems of Record
A complete view of producer or policyholder data must be sourced from many backend systems. CoreCONNECT starts with this data, drawn from inside your trusted core systems of record, to facilitate transactions for these key users.
CoreCONNECT takes feeds from policy administration, compensation and commission, producer management, document storage, digital asset and content management, new business quote, illustration, e-apply (including Sureify’s own LifetimeACQUIRE), billing, financial, access management, and more.
CoreCONNECT uses an asynchronous, stream-oriented architecture. This allows each core system to flow data on its own terms: modern, event-based systems can push data in near-real-time, while legacy systems can comfortably deliver deltas or snapshots in bulk after nightly reconciliation or batch processes. This flexibility reduces the design and development impact substantially, meaning you can quickly go live with a new digital experience layer.
Arecibo Ingest API
CoreCONNECT’s ingestion API, Arecibo, provides a secure, flexible facility for loading data of all types into your Sureify cloud instance. Because CoreCONNECT uses an asynchronous paradigm, you can push data at any time, with any granularity, and at any rate. A simple, OpenAPI-compliant interface provides for the ingestion of structured data — in JSON, XML, ACORD, fixed-width, or whatever the source format — as well as binary large objects, including PDFs and other documents, graphics, and media assets.
CoreCONNECT is engineered to handle the most demanding workloads for the largest carriers in the world. Send millions of records, terabytes of binaries, and scale out horizontally for as much throughput as you need.
CoreCONNECT streams incoming data off of Arecibo into Apache Kafka, the industry standard for processing queues and managing high volume event data at scale. Kafka *remembers* all of the data on ingress, tracking each of your systems’ data feeds for processing downstream and retaining a replica for high-speed replay in the future. You send your data one time, and CoreCONNECT carefully tracks it for life.
Next, business data is flowed into a set of custom Stream Transforms to do the hard work of converting each incoming data record into a cohered, consistent representation inside Sureify CoreCONNECT.
A fully extendable, domain-specific canonical representation comes “out of the box” with CoreCONNECT, and it’s ready with support for all life products (term life, whole life, advanced variable life and annuity products and other offerings), complex producer hierarchies, compensation and policy financials, and more. CoreCONNECT already knows insurance, because life and annuity is our only focus at Sureify.
CoreCONNECT delivers ultra-low-latency reads on your public API primarily by *pre-computing* coherence, optimizing hierarchies, and storing results as close to the edge as possible. Much like a CDN, it anticipates the questions your customers and partners will ask, and it ensures that the answers are always ready in milliseconds. Even if a core system is unavailable, your digital edge APIs and experiences remain available, 24x7x365.
The cache layer includes a traditional row-store database replete with a comprehensive, canonical life insurance data model for at-rest representation. But CoreCONNECT also stores business documents, marketing assets, and anything else that must be available on your API — and these are ready to place into your customers’ hands at the low latencies users have come to expect from modern retail experiences.
Edge Read API
CoreCONNECT’s culminates in a set of OpenAPI-compliant, fully-documented, ready-to-integrate interfaces that answer all of the questions any policyholder, producer, agent, advisor, or the people who support them may have. Straightforward HTTP REST-style queries yield rapid results in clear, concise JSON response objects — the *lingua franca* of the modern internet.
At Sureify, we design these business APIs first, so that they stay generalized and useful for any consuming client, whether in our LifetimeAGENT or LifetimeSERVICE experiences, your own web or native apps, or those of your partners. With a complete API for your business, you can tackle your pressing digitization needs today while building a stable foundation for future growth in the overall electronic experience.
Digital Experiences (DXPs)
We started building DXPs for life carriers nearly a decade ago. Over time, we’ve learned quite a bit about how to create compelling, performant solutions that deliver real business value. Today, we offer two experiences built against the CoreCONNECT Edge APIs: LifetimeAGENT, a cutting edge digital experience for agents, and LifetimeSERVICE, a complete policyholder self-servicing portal.
But CoreCONNECT is also designed to support your own DXP initiatives and those of your partners. Have a site already that feels underpowered? Want to deliver a richer, better set of answers to a distributor in real-time? Use CoreCONNECT to level up these assets and raise the bar in the marketplace.
— Write Path —
Edge Write API
We designed CoreCONNECT’s to solve the data coherence challenge, but the write path also delivers on the other side of the problem: it gives you a way to define and express all *actions* and *transactions* that users need, so they can get real work done via your API.
Similar to the , the Edge Write APIs provide a seamless and secure platform for policyholders, producers, and their supporters to easily work together with you, your systems, and your team for every transaction in a way that aligns with today's digital modern expectations. These interactive APIs, each backed by a defined , capture data in flight and unlock precise visibility across all of your insurance processes — from quote to post-issue servicing to claims management. Think of the Edge Write API as a way to simplify the process. Need to interpret policyholders’ interactive needs to decrease drop-off rates? Use meta process data to shape decisions and bring possibilities for better experiences into focus? Build strategy based on customer preferences? This revolutionary DXP makes it possible to easily gather and understand data for better user experiences.
And, to keep the CoreCONNECT Edge API seamless for your customers and partners, each interface is delivered in modern JSON over HTTP backed by a robust authentication and access model.
At the heart of CoreCONNECT’s write path is the Journey Engine. Backed by a state-of-the-art flow management framework, Journeys encode the computational structure for each runtime insurance transaction — from “Enter Applicant SSN” to “Change Beneficiary.”
At runtime, individual users can launch, inspect, interact with, and advance Journey instances along their prescribed paths. CoreCONNECT manages each Journey instance as an isolated microservice, complete with its own dedicated data bucket, status, and event history. Journey instances can hibernate and resume on the fly, so they can model long-running processes just as easily as instantaneous ones.
We deliver a set of Journey templates that model common insurance processes, but each Journey definition is extensible by a carrier/insurer as needed. Additionally, each Journey can be configured to commit its data at just the right moment to any system, queue, or downstream processing mechanism.
Got a real-time API for a certain action? Great! Every running Journey will carefully and reliably deliver the transaction, retrying or alerting if necessary.
Is another transaction only supported manually today? No worries. Journeys can format and transmit manual requests to teams or users at the home office for handling things behind the scenes.
CoreCONNECT buffers away the commit strategy, separating it in time and space from the interactive API on the edge. This lets producers and policyholders enjoy a modern, real-time experience over the internet, regardless of what capabilities or constraints might exist today behind the scenes.
Journeys make it easy for you to quickly go live and deploy full-duplex digital capability now — without requiring you to refactor any of your backend systems.