Method and system for checking guideline violations of insurance plan and supporting automatic modification

Abstract

The present invention relates to a method and system that supports checking whether an insurance plan violates guidelines and automatically correcting it, comprising: (a) receiving an insurance plan including one or more collaterals and a request to check whether the insurance plan violates guidelines; (b) determining whether the insurance plan violates guidelines; (c) if it is determined that the insurance plan violates guidelines, deriving and displaying a correction plan to ensure that the insurance plan does not violate guidelines; (d) receiving input regarding whether the correction plan is applied and / or modifications to the insurance plan; (e) modifying the insurance plan based on the input received in step (d) and determining whether the modified insurance plan violates guidelines; and (f) displaying the result of the determination in step (e).

Description

Technology Field

[0001] The present invention relates to a method and system that supports checking for and automatically correcting violations of guidelines regarding insurance design proposals. Background Technology

[0002] Generally, the insurance planning process involves a planner verifying basic information such as the insured's age, gender, occupation, and health status, selecting various coverages, and establishing the coverage amount, insurance period, and payment cycle for each coverage to create an insurance proposal. The proposal produced during this process must comply with the insurance company's internal underwriting guidelines, thereby guaranteeing the suitability of the final contract.

[0003] However, insurance companies' underwriting guidelines vary significantly by product and change frequently depending on internal policies or regulatory oversight. Consequently, the process of individually verifying and incorporating these guidelines during the insurance design phase has been identified as the most complex and time-consuming aspect. In particular, as guidelines are frequently accumulated and managed manually by numerous personnel, issues often arise where identical meanings are recorded using different expressions or where the latest information is not immediately reflected. This inconsistency hinders automated verification and places an excessive burden of manual work on insurance agents.

[0004] To mitigate these issues, some sales sites operate a 'design manager system' employing personnel to handle design work on behalf of others. However, this leads to the side effect of significantly increasing labor costs, and there are limitations in that it is difficult to respond stably by relying solely on manpower due to the short cycle of guideline changes.

[0005] Therefore, there is a need for a system and method that automatically verifies the guideline compliance of insurance design proposals and supports corrective measures to resolve violations. Prior art literature

[0006] Korean Patent Publication No. 10-2793143 (Registered on April 3, 2025) The problem to be solved

[0007] The technical problem that the present invention aims to solve is to support insurance agents in completing a suitable insurance plan quickly and accurately by automatically verifying whether an insurance plan violates an insurance company's underwriting guidelines, deriving a corrective plan to resolve violations if any exist, and intuitively providing it to the agent's terminal.

[0008] In addition, the technical problem that the present invention aims to solve is to enable stable guideline verification without completely restructuring existing guidelines or continuously maintaining and repairing rule-based systems, even in an operational environment where guidelines are accumulated and managed manually by numerous personnel and are changed frequently.

[0009] The technical problems of the present invention are not limited to those mentioned above, and other unmentioned technical problems will be clearly understood by a person skilled in the art from the description below. means of solving the problem

[0010] A method for verifying whether an insurance design plan violates guidelines and supporting automatic correction according to an embodiment of the present invention for achieving the above technical problem comprises: (a) receiving a request to verify whether the insurance design plan violates guidelines, and an insurance design plan including one or more collaterals; (b) determining whether the insurance design plan violates guidelines; (c) if it is determined that the insurance design plan violates guidelines, deriving and displaying a correction plan to ensure that the insurance design plan does not violate guidelines; (d) receiving input regarding whether the correction plan is applied and / or modification details for the insurance design plan; (e) modifying the insurance design plan based on the input received in step (d) and determining whether the modified insurance design plan violates guidelines; and (f) displaying the result of the determination in step (e).

[0011] In addition, according to one embodiment of the present invention, the method for verifying whether an insurance design plan violates guidelines and supporting automatic correction may further include a step of indicating one or more guidelines that the insurance design plan violates when it is determined that the insurance design plan violates the guidelines after step (b) and before step (c).

[0012] In addition, according to one embodiment of the present invention, a method for verifying whether an insurance design plan violates guidelines and supporting automatic correction may further include, after a step of indicating one or more guidelines that the insurance design plan violates, a step of receiving input of corrections to said insurance design plan, and a step of determining whether said insurance design plan violates guidelines.

[0013] In addition, according to one embodiment of the present invention, the method for verifying whether an insurance design plan violates guidelines and supporting automatic correction may include, in step (b), (b-1) a step of querying one or more guidelines corresponding to the insurance design plan in a guideline database, and (b-2) a step of determining whether there is a guideline among the queried guidelines that the insurance design plan violates.

[0014] Additionally, according to one embodiment of the present invention, the guideline is text containing at least one of the contents regarding the name of the coverage, the coverage amount, gender, and age for the coverage, and the step (b-1) comprises (b-1-1) a step of normalizing each guideline stored in the guideline database to generate each guideline entry, and (b-1-2) a step of querying one or more guideline entries corresponding to the insurance design plan, and the step (b-2) may be a step of determining whether there is a guideline among the queried guideline entries that the insurance design plan violates.

[0015] A server for verifying violation of insurance design guidelines and supporting automatic correction according to an embodiment of the present invention for achieving the above technical problem comprises a central processing unit and a memory, wherein the central processing unit executes commands for executing a method for verifying violation of insurance design guidelines and supporting automatic correction stored in the memory, wherein the method for verifying violation of insurance design guidelines and supporting automatic correction comprises: (A) receiving an insurance design including one or more coverages and a request to verify whether the insurance design includes a violation of guidelines; (B) determining whether the insurance design includes a violation of guidelines; (C) if it is determined that the insurance design includes a violation of guidelines, deriving and displaying a correction plan to ensure that the insurance design does not violate the guidelines; (D) receiving input regarding whether the correction plan is applied and / or modification details regarding the insurance design; (E) modifying the insurance design based on the input received in step (D) and determining whether the modified insurance design includes a violation of guidelines; and (F) displaying the result of the determination in step (E). It can be included. Effects of the invention

[0016] According to one embodiment of the present invention, the present invention automatically verifies whether an insurance plan violates the underwriting guidelines of an insurer, and if violations exist, derives a correction plan to resolve them and intuitively provides it to the planner's terminal, thereby having the effect of supporting a planner to quickly and accurately complete a suitable insurance plan.

[0017] In addition, according to one embodiment of the present invention, the present invention has the effect of enabling stable guideline verification without completely restructuring existing guidelines or continuously maintaining and repairing rule-based systems, even in an operational environment where guidelines are manually accumulated and managed by numerous personnel and are changed frequently.

[0018] The effects of the present invention are not limited to those mentioned above, and other unmentioned effects will be clearly understood by a person skilled in the art from the description below. Brief explanation of the drawing

[0019] FIG. 1 is a diagram showing the schematic configuration of a system for verifying whether an insurance design plan guideline is violated and supporting automatic correction according to an embodiment of the present invention. FIG. 2 is a diagram showing the configuration of a service server according to an embodiment of the present invention. FIG. 3 is a flowchart showing representative steps of a method for verifying whether an insurance design plan guideline is violated and supporting automatic correction according to the first embodiment of the present invention. FIGS. 4 to 7 are schematic drawings illustrating a user interface screen according to a first embodiment of the present invention. Specific details for implementing the invention

[0020] The advantages and features of the present invention and the methods for achieving them will become clear by referring to the embodiments described below in conjunction with the accompanying drawings. However, the present invention is not limited to the embodiments disclosed below but may be implemented in various different forms. These embodiments are provided merely to ensure that the disclosure of the present invention is complete and to fully inform those skilled in the art of the scope of the invention, and the present invention is defined only by the scope of the claims.

[0021] The terms used in this specification will be briefly explained, and the invention will be described in detail.

[0022] The terms used in this invention have been selected based on currently widely used general terms, taking into account their functions within the invention; however, these terms may vary depending on the intent of those skilled in the art, case law, the emergence of new technologies, etc. Additionally, in specific cases, terms have been arbitrarily selected by the applicant, and in such cases, their meanings will be described in detail in the relevant description of the invention. Therefore, the terms used in this invention should be defined not merely by their names, but based on their meanings and the overall content of the invention.

[0023] Throughout the specification, when a part is described as "comprising" a certain component, this means that, unless specifically stated otherwise, it does not exclude other components but may include additional components. Furthermore, terms such as "part," "module," and "unit" used in the specification refer to a unit that processes at least one function or operation and may be implemented as software, hardware components such as FPGAs or ASICs, or a combination of software and hardware. However, the terms "part," "module," and "unit" are not limited to software or hardware. "Part," "module," and "unit" may be configured to reside in an addressable storage medium or configured to run one or more processors. Accordingly, as an example, terms such as "part," "module," and "unit" include components such as software components, object-oriented software components, class components, and task components, as well as processes, functions, attributes, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuits, data, databases, data structures, tables, arrays, and variables.

[0024] Below, embodiments of the present invention are described in detail with reference to the attached drawings so that those skilled in the art can easily implement the invention. Additionally, parts of the drawings that are irrelevant to the description are omitted to clearly explain the invention.

[0025] Terms including ordinal numbers, such as "first," "second," etc., may be used to describe various components, but the components are not limited by the terms. The terms are used solely for the purpose of distinguishing one component from another. For example, without departing from the scope of the present invention, the first component may be named the second component, and similarly, the second component may be named the first component. The term "and / or" includes a combination of multiple related items or any one of the multiple related items.

[0026] The method for verifying whether an insurance plan violates guidelines and supporting automatic correction, which is to be described in this invention, can be understood as a technology that automates and supports the process of verifying whether an insurance plan written by a planner complies with internal regulations or guidelines during the entire insurance design process performed to propose an insurance product to a customer, and suggesting correction measures to resolve the violation if one is found to be in violation.

[0027] Before proceeding with a full description of the present invention, we will briefly explain the key terms used in the present invention.

[0028] First, an insurance plan refers to design data in the form of a draft of an insurance contract, comprising the insured's basic information (e.g., age, gender, occupation, health status, etc.), one or more coverages, the coverage amount for each coverage, the insurance period, the payment cycle, the calculated premium, and basic information for premium calculation. In other words, an insurance plan has a structure in which the overall coverage details are formed by the selection and combination of multiple coverages.

[0029] Next, coverage refers to the risk factors or coverage items designated as the subject of coverage in an insurance plan. Specifically, coverage is an element that defines the grounds for the payment of insurance benefits that the insurer must make upon the occurrence of specific diseases, injuries, death, disasters, etc., and the coverage amount, scope of coverage, and exclusion conditions can be individually set for each type of coverage. As a core component of the insurance plan, coverage details and premiums are determined based on the types and combinations of selected coverage.

[0030] Furthermore, guidelines refer to standard information used to determine whether an insurance plan has been drafted in compliance with internal regulations or company policies. Specifically, guidelines may include detailed conditions such as the eligible age for specific coverage, gender requirements, upper and lower limits on coverage amounts, permitted or prohibited combinations of coverage, mandatory linked coverages, and reasons for enrollment restrictions based on specific occupations or health conditions. Guidelines may be changed or added to from time to time in accordance with the insurer's internal regulations or supervisory guidelines; thus, they function as a key reference standard for verifying the suitability of insurance plans.

[0031] This concludes the explanation of the key terms used in the present invention. Below, we will examine embodiments of the present invention with reference to the drawings.

[0032] First, FIG. 1 is a schematic diagram for conceptually understanding the insurance design plan guideline violation verification and automatic correction support system (hereinafter referred to as the "system") according to the present invention. The entire system may be composed of a service server (100), a design agent terminal (200), and a core system server (300) as its main components.

[0033] The service server, which is the component primarily mentioned in this detailed description, can be understood as the entity providing the service for verifying violations of insurance design guidelines and supporting automatic corrections according to the present invention. Specifically, the service server receives a request to verify insurance design plans and guidelines from a planner terminal, determines whether there is a violation through comparison with a guideline database, and, if necessary, derives a correction plan and provides it to the planner terminal. Therefore, the service server can be considered a central component that performs the overall operation of the present invention.

[0034] The insurance agent terminal can be understood as a user-side device that creates and views insurance plan proposals and receives services for verifying guideline violations and supporting automatic corrections through communication with a service server. Specifically, the insurance agent terminal may include a display unit, an input unit, and a control unit, and may further include a communication unit as necessary. The display unit can visually output guideline violation results or correction proposals received from the service server to the screen, and the input unit enables the user to create an insurance plan proposal, select whether to apply a correction proposal, and directly input modifications. The control unit controls the operation of the display unit and the input unit, and the communication unit transmits and receives insurance plan proposals and related data through a wired or wireless network connection with the service server. Accordingly, the insurance agent terminal functions as an interface device connecting the insurance agent and the service server during the implementation of the present invention.

[0035] More specifically, the designer terminal may include a display unit, an input unit, and a control unit, and may further include a communication unit. The display unit may visually output information processed by the control unit, information recorded in the information storage unit, and information collected from a wired or wireless network through the communication unit. The input unit may detect user input having at least one type and provide the detected user input as an identifiable signal by the control unit. The display unit and the input unit may be provided in a form integrated into a single hardware module, such as a touch screen. The control unit refers to a unit that processes a function or operation for a user to perform input, and may be implemented in hardware, software, or a combination of hardware and software. The control unit controls the operation of at least one of the display unit, input unit, and communication unit, and may include, in hardware, at least one of ASICs (application specific integrated circuits), DSPs (digital signal processors), DSPDs (digital signal processing devices), PLDs (programmable logic devices), FPGAs (field programmable gate arrays), microprocessors, and other electrical units for performing functions.The control unit may be equipped with an information storage unit, and the information storage unit may include at least one type of storage medium among a flash memory type, a hard disk type, an SSD type (Solid State Disk type), an SSD type (Silicon Disk Drive type), a multimedia card micro type, RAM (random access memory), SRAM (static random access memory), ROM (read-only memory), EEPROM (electrically erasable programmable read-only memory), and PROM (programmable read-only memory). The information storage unit may include a computer-readable recording medium on which a computer program is recorded for executing the method for verifying whether an insurance design plan violates guidelines and supporting automatic correction according to the present invention. The communication unit may transmit and receive information by connecting to another device within the system for verifying whether an insurance design plan violates guidelines and supporting automatic correction via a wired or wireless network.

[0036] Meanwhile, in the present disclosure, the designer terminal may be understood as a terminal owned or possessed by a 'designer' who receives a service for verifying violations of insurance design guidelines and supporting automatic correction, which can be implemented by the method and system for verifying violations of insurance design guidelines and supporting automatic correction according to an embodiment of the present invention.

[0037] The core system server can be understood as a backend system that manages insurance products, contracts, customer information, and guideline databases in conjunction with the insurance company's existing internal systems. Specifically, the core system server includes databases and business processing modules maintained and operated within the insurance company's computer network. Through integration with service servers, it can provide the latest guideline information necessary for verifying insurance proposals or store and manage finalized proposals. Furthermore, the core system server ensures the reliability and consistency of the entire system by periodically updating guideline data in accordance with changes in insurance company policies or regulations from supervisory authorities, and by supporting service servers to reference this data.

[0038] FIG. 2 is a diagram showing the configuration of a service server (100) according to an embodiment of the present invention.

[0039] Referring to FIG. 2, the service server (100) is described more specifically. The service server (100) may include a processor (10), a network interface (20), a memory (30), a storage (40), and a data bus (50) connecting them, and may also include other additional components required to achieve the purpose of the present invention.

[0040] The processor (10) controls the overall operation of each component. The processor (10) may be any one of a CPU (Central Processing Unit), MPU (Micro Processor Unit), MCU (Micro Controller Unit), or a type of processor widely known in the technical field to which the present invention belongs, and may be implemented as an artificial intelligence model processor, such as a machine learning model processor or a deep learning model processor. In addition, the processor (10) may perform operations on at least one application or program to perform a method for verifying whether there is a violation of insurance design guidelines and supporting automatic correction according to an embodiment of the present invention.

[0041] The network interface (20) supports wired and wireless communication of the system (100) according to one embodiment of the present invention and may also support other known communication methods. Accordingly, the network interface (20) may be configured to include a communication module accordingly.

[0042] The memory (30) stores various information, commands and / or information, and can load one or more computer programs (41) from the storage (40) to perform a method for verifying whether there is a violation of insurance design guidelines and supporting automatic correction according to an embodiment of the present invention. In FIG. 1, RAM is shown as one of the memory (30), but it is obvious that various storage media can also be used as memory (30).

[0043] Storage (40) can store one or more computer programs (41) and large network information (42) non-temporarily. This storage (40) may be any one of non-volatile memory such as ROM (Read Only Memory), EPROM (Erasable Programmable ROM), EEPROM (Electrically Erasable Programmable ROM), flash memory, a hard disk, a removable disk, or any type of computer-readable recording medium widely known in the art to which the present invention belongs.

[0044] A computer program (41) is loaded into memory (30) and can execute the following operations: (A) receiving a request to verify whether the insurance plan includes one or more collaterals and whether the insurance plan violates guidelines; (B) determining whether the insurance plan violates guidelines; (C) if it is determined that the insurance plan violates guidelines, deriving and displaying a correction plan to ensure that the insurance plan does not violate guidelines; (D) receiving input regarding whether the correction plan is applied and / or modifications to the insurance plan; (E) modifying the insurance plan based on the input received in operation (D) and determining whether the modified insurance plan violates guidelines; and (F) displaying the result of the judgment in operation (E).

[0045] The operation performed by the computer program (41) briefly mentioned above can be viewed as one function of the computer program (41). Meanwhile, a more detailed explanation of the operation performed by the computer program (41) described above will be provided later in the description of the method for verifying whether there is a violation of insurance design guidelines and supporting automatic correction according to an embodiment of the present invention.

[0046] The data bus (50) serves as a path for the movement of commands and / or information between the processor (10), network interface (20), memory (30), and storage (40) described above.

[0047] The system (100) according to one embodiment of the present invention, as briefly described above, may be in the form of an independent device or a component of another device. Here, the device may be any device that has a CPU corresponding to a processor (10) installed, such as a server computer supporting wired or wireless communication, possesses network functions, and is connected to a user terminal (200) via a network to perform each step of the method for verifying whether there is a violation of insurance design guidelines and supporting automatic correction.

[0048] For example, the service server (100) may be implemented by a server computer including memory and a processor, or it may be implemented separately by physically independent hardware, or it may be implemented in a functionally independent form by a cloud system, etc. As long as the operation described below can be executed, the physical form of the device and the service server (100) is not limited.

[0049] Hereinafter, with reference to FIGS. 3 to 7, the process of providing a method for checking whether an insurance plan guideline is violated and providing a method for automatically correcting an insurance plan guideline that can be implemented by the aforementioned insurance plan guideline violation check and automatic correction support system will be explained.

[0050] However, this is merely a preferred embodiment for achieving the purpose of the present invention, and it goes without saying that some steps may be added or deleted as needed, and any one step may be included in another step.

[0052] <First Example>

[0053] FIG. 3 is a flowchart showing representative steps of a method for verifying whether an insurance design plan guideline is violated and supporting automatic correction according to the first embodiment of the present invention.

[0054] Referring to FIG. 3, the method for checking whether an insurance plan guideline is violated and for supporting automatic correction according to the first embodiment of the present invention may first begin with a service server receiving from a designer terminal an insurance plan including one or more coverages and a request to check whether the insurance plan guideline is violated (S100).

[0055] Specifically, the agent terminal can create a new insurance plan or load an externally created plan and display it on the screen via a dedicated application. Here, the insurance plan generally includes the insured's basic information (e.g., age, gender, occupation, health status, etc.), along with the types of selected coverage, the coverage amount for each coverage, the insurance period, the payment cycle, the calculated premium, and the basic information used to calculate the premium. Once the insurance plan is prepared on the application, a button may be displayed on the user interface to check whether the plan violates guidelines. If the agent selects this button, the agent terminal generates a guideline verification request signal along with all or part of the insurance plan data and transmits it to the service server.

[0056] Meanwhile, an example of a user interface provided to a designer terminal in the aforementioned step S100 can be represented as shown in FIG. 4.

[0057] Afterwards, the service server can determine whether the insurance design plan received at step S100 violates the guidelines (S200).

[0058] Specifically, step S200 is a step of verifying suitability by comparing each item of the insurance design proposal with the guidelines stored in the guideline database, and can be performed by including the detailed steps S210 to S220.

[0059] Step S210 is a step in which the service server queries the guideline database for one or more guidelines corresponding to the insurance design plan.

[0060] Specifically, step S210 can be understood as a step of identifying matching guidelines by searching for guidelines stored in a guideline database based on the coverage composition, coverage amount, and coverage conditions of the insurance plan. More specifically, the aforementioned step S210 may be performed by including steps S211 to S212, which will be described below.

[0061] Meanwhile, in one embodiment of the present invention, the guideline database may be stored and managed directly on a service server, and in another embodiment, it may be stored and operated on an insurer's core server. When the guideline database is stored on a core server, the service server may perform a communication process with the core server to search for guidelines corresponding to the insurance design proposal. In this process, the service server transmits a query request to the core server via a network, receives a response from the core server regarding matching guidelines, and utilizes them in a subsequent step.

[0062] Step S211 is a step in which the service server normalizes each guideline stored in the guideline database to generate each guideline entry.

[0063] To explain in detail, guidelines can include various elements such as coverage name, coverage amount, gender, age, special clause conditions, payment cycle, and reasons for enrollment restrictions. For instance, in the industry, it is common for numerous personnel to manage guidelines by manually entering them into Excel files or internal documents in different ways, which can result in the accumulation of thousands to tens of thousands of entries. Even if these guidelines convey the same meaning, they may be stored using different formats depending on the author or the system. For instance, different names such as "General Cancer," "Cancer (General)," or "C01" may be used for the same coverage, and the coverage amount may also be recorded in various notations, such as "30 million won" or "30,000,000 won."

[0064] Therefore, to convert these guidelines into a consistent format, the service server standardizes the text using predefined rules or machine learning / natural language processing models and breaks it down into fields based on semantic units (e.g., coverage name, amount unit, age range, applicable gender, etc.). As a result of this normalization process, each guideline is stored as a guideline entry in the form of structured data, preparing it for direct comparison and verification with items in the insurance plan at a later stage.

[0065] Furthermore, during the normalization process of guidelines, the service server does not merely perform simple string conversions; it can also apply a predefined rule set to unify numerical units, remove unnecessary symbols, and map different expressions to the same standard word according to a thesaurus. Moreover, in cases where consistency is difficult to ensure with rule-based preprocessing alone, the service server can utilize machine learning / natural language processing modules, such as Large Language Models (LLM), to interpret the contextual meaning of the guidelines and automatically classify which item the guideline corresponds to, such as coverage name, subscription amount, age limit, gender condition, or special clause status. Through this process, the generated guideline entries possess a standardized structure regardless of how they were written by humans or the system environment, thereby significantly improving the accuracy and consistency of the comparison and judgment processes in subsequent stages.

[0066] Consequently, the service server converts each guideline into a guideline entry, which is a structured data unit. A guideline entry may include field configurations such as, for example, {“Coverage Name: General Cancer”, “Subscription Amount: 30,000,000”, “Age Limit: 20~60 years”, “Gender: Irrelevant”}.

[0067] Meanwhile, the aforementioned step S211 is not limited to being repeatedly performed whenever the method for verifying violations of insurance design guidelines and supporting automatic correction according to an embodiment of the present invention is executed. For example, it may be newly performed only when a change or update occurs in the guidelines stored in the guideline database, or it may be implemented in a form that generates and manages the latest guideline entries in advance by being performed independently in advance, regardless of the order of each step according to the first embodiment of the present invention. Accordingly, step S211 can be modified in various ways, such as real-time execution, event-based execution, or pre-preparation execution, and this is included within the technical scope of the present invention.

[0068] On the other hand, according to one embodiment of the present invention, the service server may be implemented to not only normalize each guideline in step S211 to generate a guideline entry, but also to actively detect semantic conflicts or ambiguities between guideline entries existing in the guideline database.

[0069] Specifically, the service server can convert the semantics of each guideline entry into a vector using a large-scale language model (LLM) or a natural language processing module, and then the service server can compare the semantic similarity between the vector of a specific guideline entry (e.g., a newly added or changed guideline) and the vectors of other guideline entries within the guideline database.

[0070] When comparison results reveal pairs of entries where the meanings of core items such as 'coverage name' or 'coverage subject' are very similar (e.g., "general cancer diagnosis benefit" and "major cancer coverage"), but the meanings of condition items such as 'coverage amount limit' or 'eligible age' are different (e.g., "maximum 30 million won" and "maximum 50 million won"), the service server may identify this as a 'potential conflict' or 'ambiguity'.

[0071] The service server can transmit the list of potential conflicts / ambiguities identified in this way to a separate instruction manager interface (not shown) rather than to the insurance planner terminal (200), so that the manager can directly verify and modify it.

[0072] This feature can help fundamentally resolve issues of data contradictions or inconsistencies that may arise in operational environments where guidelines are manually accumulated and managed by numerous personnel. Furthermore, by supporting the continuous maintenance and upkeep of the database's consistency without the need for a complete restructuring of existing guidelines, it has the effect of further enhancing the reliability of guideline verification.

[0073] Step S212 is a step in which the service server queries one or more guideline entries corresponding to the insurance design plan.

[0074] Specifically, the service server can retrieve guideline entries corresponding to each item (e.g., coverage name, coverage amount, age, gender condition, etc.) of the insurance plan received in step S100 by searching the guideline database. In this process, the items of the insurance plan are mapped to be comparable with guideline entries converted into a pre-normalized format, thereby allowing verification of whether the coverage is identical, whether the amount limit is met, and whether the age and gender conditions match. For example, if the insurance plan includes coverage of “General Cancer 30 million won,” the service server queries the guideline database for guideline entries such as {“Coverage Name: General Cancer”, “Coverage Amount Limit: 30,000,000”, “Age Limit: 20~60 years”} and uses them as reference data for determining whether there is a violation in the subsequent step (S220).

[0075] Step S220 is a step for determining whether there are any guidelines among the aforementioned retrieved guidelines that the insurance design plan violates.

[0076] Specifically, the service server verifies suitability by comparing the guideline entries retrieved in step S212 with each item of the insurance plan item by item. For instance, this applies when the coverage amount of a benefit included in the plan exceeds the maximum limit for that benefit, when the insured's age falls outside the age range permitted by the guidelines, or when a combination of specific benefits and special riders is not allowed under internal regulations. Through this comparison process, the service server can determine whether the insurance plan violates one or more guidelines; if a violation is found, it identifies the relevant guideline and prepares to display it to the user in a subsequent step.

[0077] In summary, step S200 according to the first embodiment of the present invention described above can be understood as a series of processes for determining whether there is a violation by comparing each item of an insurance design proposal with the guidelines stored in the guideline database. In particular, in the industry, thousands or tens of thousands of guidelines have already been manually accumulated in the form of Excel files or internal documents, and these guidelines are expressed differently by each person in charge and are changed or added on a monthly or bi-weekly basis. Therefore, fully structuring and standardizing all guidelines in advance not only incurs massive development costs but also leads to a problem where human risk increases due to the burden of continuously maintaining and updating the rules.

[0078] Accordingly, the present invention proposes a method that utilizes existing accumulated handwritten instruction text as is, while allowing a service server to normalize and standardize it to convert it into instruction item entries and directly compare it with insurance design proposals. According to this method, expression styles that differ among personnel (e.g., inconsistencies in period notation such as “10 years” or “120 months”; inconsistencies in job title notation such as “office worker”, “office staff”, or “employee”; inconsistencies in currency notation such as “5 million won” or “KRW 5,000,000”) can be automatically unified, and human errors occurring during the manual input process can be partially corrected. As a result, since there is no need to maintain a separate comprehensive structuring or rule-based system, management costs and burdens are significantly reduced, and a system is maintained that allows the field to freely continue updating handwritten instructions. Therefore, the S200 step of the present invention is optimized for existing handwritten-based environments, while simultaneously achieving accuracy and consistency in determining whether there is a violation of the instructions. This concludes the description of step S200. Below, steps S300 to S600 according to the first embodiment of the present invention will be described.

[0079] Subsequently, if the service server determines that the insurance plan received in step S100 violates the guidelines, it may derive a correction plan to ensure that the insurance plan does not violate the guidelines and display it on the planner's terminal (S300).

[0080] To explain in detail, the service server can automatically generate one or more correction proposals to modify the insurance plan based on guidelines that the plan violates. For example, if the coverage amount for a specific benefit exceeds the limit permitted by the guidelines, the service server can generate a correction proposal that automatically adjusts the coverage amount to the permitted limit. As another example, if a benefit that is unavailable for enrollment in a specific age group is included, the service server can generate a correction proposal that removes the benefit or proposes a replacement. Furthermore, there may be cases where the addition of a specific benefit in accordance with the guidelines necessitates the inclusion of other linked benefits; in such cases, the service server can automatically include the omitted linked benefits or propose a replacement proposal that adds the linked benefits.

[0081] The generated correction proposals are displayed on the designer's terminal via the user interface screen, and the designer can review or select whether to apply each correction proposal. In this way, Step S300 goes beyond merely notifying the violation to providing specific corrective measures to resolve the violation, thereby significantly improving the designer's work efficiency and the level of automation of the entire process.

[0082] In addition, the correction proposal derived by the service server can be intuitively displayed through the user interface screen of the insurance agent's terminal. For example, the screen may highlight the guidelines that the original items of the insurance plan violate, along with a correction proposal to resolve the issue, presented as an alternative. Specifically, if an excess coverage amount is included, the original and adjusted values ​​are displayed side-by-side, such as “Existing coverage amount: 40,000,000 KRW / Allowable limit: 30,000,000 KRW,” and the agent can select whether to apply the correction proposal via a button or checkbox. As another example, if coverage ineligible for a specific age group is included, the relevant coverage is highlighted in a warning color on the screen, and a list of alternative coverages is presented alongside it, allowing the agent to make an immediate selection. Furthermore, if linked coverage conditions apply, a notification such as “Coverage B automatically included when Coverage A is selected” is displayed on the screen, supporting the agent in completing a plan that complies with guidelines through simple selection.

[0083] Meanwhile, an example of a user interface provided to a designer terminal in the aforementioned S300 step can be represented as shown in FIG. 6.

[0084] On the other hand, according to another embodiment of the present invention, the correction plan derived in step S300 may not be limited to a single correction plan that simply resolves the guideline violation. That is, the service server may be implemented to consider the entire context of the violated item and the design plan, infer the designer's original intent, and generate and present multiple intelligent correction plans capable of satisfying it.

[0085] For example, if the coverage amount for 'Ischemic Heart Disease Diagnosis Benefit' violates the 'maximum 30 million won' guideline, the service server can derive various correction plans such as the following.

[0086] [Proposed Amendment 1 - Minimum Change]: "Existing subscription amount lowered from 50 million KRW to 30 million KRW"

[0087] [Proposal 2 - Plan to Maintain Coverage Intent]: "Downward adjustment of existing coverage to 30 million KRW + new addition of 'Coverage B' of 20 million KRW, which is of a similar coverage nature (Total coverage amount maintained at 50 million KRW)"

[0088] [Proposed Amendment 3 - Conditional Increase]: "If the OO Rider is added, the applicable coverage limit will be increased to 50 million KRW. Would you like to add the OO Rider?"

[0089] In this way, the service server can support the planner by generating multiple alternatives that maintain or achieve the planner's original intention (e.g., securing coverage of 50 million won) rather than simply modifications or corrections that pass the guidelines.

[0090] Furthermore, the present invention may be implemented to optimize the correction proposal generation model itself by utilizing the designer's selection of these multiple correction proposals as feedback in step S400.

[0091] Specifically, the service server can be implemented to collect training data in the S400 stage regarding the history of a designer selecting a specific correction plan among several correction plans, or the history of ignoring correction plans and performing direct modifications, and to utilize this data as a reward signal or correct label for a reinforcement learning or active learning model to continuously tune the correction plan generation logic. As a result, the system gradually learns the optimal solution patterns preferred by experienced designers, and over time, it prioritizes proposing correction plans that are more intelligent and aligned with the intentions of the field.

[0092] Next, the service server may receive input (S400) from the designer terminal regarding whether to apply the correction plan derived in step S300 and / or modifications to the insurance design plan.

[0093] Specifically, one or more correction proposals presented in step S300 are displayed on the user interface of the agent terminal, and the agent can select whether to apply each correction proposal. For example, if a correction proposal that adjusts the excess coverage amount is displayed, the agent can accept the correction proposal by pressing the “Apply” button or maintain the original plan by selecting the “Ignore” button. In addition, the agent can directly modify the details of the insurance plan in addition to selecting a correction proposal, and can input changes such as adding new coverage or changing the coverage amount of existing coverage. The service server aggregates the selection results and direct input received from the agent terminal in this manner to obtain the modified insurance plan for determining whether there is a violation of the guidelines in the subsequent step (S500).

[0094] Subsequently, the service server may modify the insurance design plan received in step S100 based on the input received in step S400 (input regarding whether the correction plan is applied and / or modifications to the insurance design plan), and determine whether the modified insurance design plan violates the guidelines (S500).

[0095] Specifically, the service server automatically updates the items of the insurance plan by reflecting the results of applying correction proposals received from the planner's terminal, or generates a new plan by reflecting modifications directly entered by the planner. The updated insurance plan is then compared against the guideline entries stored in the guideline database. For instance, if an excess coverage amount is adjusted to the allowable limit, the server re-evaluates whether that amount actually falls within the permitted range, and can also re-verify whether newly added coverage violates linkage conditions or combination restriction conditions. Through this iterative verification process, the service server determines once again whether the modified insurance plan still violates the guidelines.

[0096] Afterwards, the service server can display the result (S600) of whether the modified insurance design plan determined in step S500 violates the guidelines.

[0097] Specifically, if the modified insurance plan satisfies all guidelines, the service server may display a confirmation message, such as “no guideline violations,” on the user interface of the agent's terminal and terminate the procedure. Conversely, if one or more guidelines are still violated, the service server may highlight the violations using warning colors, icons, or pop-up messages, and provide specific details of the violated guidelines (e.g., “Coverage A cannot be purchased by those aged 65 or older,” “Coverage B cannot be purchased in duplicate with Coverage C”). At this point, the agent may request the derivation of an additional correction plan on the user interface, and the service server returns to step S300 in response to the request to present a new correction plan and repeats the subsequent steps to support the completion of an insurance plan that ultimately complies with the guidelines.

[0098] Meanwhile, an example of a user interface provided to a designer terminal in the aforementioned S600 step can be represented as shown in FIG. 7.

[0099] Above, we have specifically examined the method for verifying whether an insurance design plan violates guidelines and supporting automatic correction according to the first embodiment of the present invention.

[0100] Next, we will examine the method for verifying whether there is a violation of insurance design guidelines and supporting automatic correction according to the second embodiment of the present invention.

[0102] <Second Embodiment>

[0103] Compared to the first embodiment described above, the second embodiment of the present invention does not differ significantly in the overall process itself; however, it differs from the first embodiment in that, upon confirmation of a guideline violation, it does not immediately proceed to an automatic correction procedure, but rather first displays the specific guideline violations of the insurance plan on the agent's terminal and explains the reason for the violation. Through this, the agent can directly verify the presented violations and, if necessary, choose whether to manually modify the insurance plan or proceed to the automatic correction stage. In other words, the second embodiment is distinguished from the first embodiment in that it provides not only automated correction support but also an additional manual correction path that allows experienced agents to flexibly intervene depending on the situation.

[0104] The method for verifying whether an insurance design plan violates guidelines and supporting automatic correction according to the second embodiment of the present invention performs steps S100 and S200 in the same manner as the first embodiment, and if it is determined in step S200 that the insurance design plan violates the guidelines, before performing step S300, the service server may perform a step of displaying one or more guidelines that the insurance design plan violated to the designer terminal.

[0105] Specifically, if the service server determines at stage S200 that a specific insurance plan violates one or more guidelines, it may display the relevant violations and the reasons on the user interface screen of the agent's terminal. For example, if the issue is an excess coverage amount, the original plan item and the violated guideline may be displayed side-by-side, such as “Coverage A: Coverage Amount 40,000,000 KRW (Allowed Limit: 30,000,000 KRW).” If the age limit is violated, a notification such as “Coverage B: Enrollment Age 65 (Allowed Age: Max. 60)” may be highlighted in a warning color. In this case, the agent can review the violations displayed on the screen and manually correct the plan by directly modifying the amount or deleting and replacing the coverage. Additionally, the service server may provide an explanation of the violated guidelines or a summary of relevant regulations to support the agent in making manual corrections.

[0106] Meanwhile, in the step of displaying the aforementioned violation items and the reasons therefor on the user interface screen of the designer terminal, an example of a user interface provided to the designer terminal can be represented as shown in FIG. 5.

[0107] Subsequently, the service server can perform the step of receiving input for modifications to the insurance design plan.

[0108] Specifically, after reviewing the violation guidelines indicated in step S200, the planner can directly modify the coverage structure, coverage amount, and presence of special riders of the insurance plan as necessary. This manual modification function is intended to support experienced planners in correcting plans based on their experience and judgment, rather than relying on automatically presented correction plans. Alternatively, the user may proceed directly to the step of applying automatic correction plans without separate manual modifications; in this case, the service server can continue processing to the next steps (S300–S600) without any input.

[0109] Subsequently, the service server may perform a step of determining whether the above insurance design plan violates the guidelines.

[0110] Specifically, the service server receives an insurance plan manually modified by a planner and verifies its suitability by comparing each item of the modified plan against the guideline entries stored in the guideline database. For example, if the planner directly adjusts an excess coverage amount or deletes or replaces specific coverages, the service server re-verifies whether these modifications satisfy the conditions permitted by the guidelines. In this way, this step determines whether the manually modified insurance plan still violates the guidelines.

[0111] Subsequently, the service server according to the second embodiment of the present invention can complete the automatic modification and verification process to ensure that the insurance design proposal conforms to the guidelines by performing steps S300 to S600 in the same manner as the first embodiment.

[0112] Meanwhile, in the step of determining whether there is a violation of guidelines regarding an insurance plan, such as in step S200, step S500, etc. in the present disclosure, if the service server determines that the insurance plan does not violate any guidelines, it may display the result of the determination on the planner terminal and terminate the procedure.

[0113] Meanwhile, in the present disclosure, the expressions that an insurance design plan "violates guidelines" or "violates guideline entries" are not limited to distinct concepts but can be understood as encompassing the meaning that the insurance design plan has violated the relevant guidelines.

[0114] Although embodiments of the present invention have been described above with reference to the attached drawings, those skilled in the art will understand that the present invention may be implemented in other specific forms without changing its technical concept or essential features. Therefore, the embodiments described above should be understood as illustrative in all respects and not restrictive.

[0115] The various embodiments of this document and the terms used therein are not intended to limit the technical features described in this document to specific embodiments and should be understood to include various modifications, equivalents, or substitutions of such embodiments. In connection with the description of the drawings, similar reference numerals may be used for similar or related components. Singular forms of nouns (e.g., prompt, data, information, model, input, voice) may include one or a plurality unless the relevant context clearly indicates otherwise.

[0116] In this document, each of the phrases such as “A or B,” “at least one of A and B,” “at least one of A or B,” “A, B or C,” “at least one of A, B and C,” and “at least one of A, B, or C” may include all possible combinations of items listed together in the corresponding phrase. Terms such as “1,” “2,” or “first” or “second” may be used simply to distinguish a component from another component and do not limit the components in any other aspect (e.g., importance or order). Where any (e.g., 1st) component is referred to as “coupled” or “connected” to another (e.g., 2nd) component, with or without the terms “functionally” or “communicationly,” it means that the component may be connected to the other component directly (e.g., wired), wirelessly, or through a third component.

[0117] As used in this document, the term "module" may include a unit implemented in hardware, software, or firmware, and may be used interchangeably with terms such as logic, logic block, component, or circuit. A module may be a component formed integrally, or a minimum unit of a component or part thereof that performs one or more functions. For example, according to one embodiment, a module may be implemented in the form of an application-specific integrated circuit (ASIC).

[0118] Various embodiments of this document may be implemented as software (e.g., a program) comprising one or more instructions stored in a storage medium (e.g., memory) that can be read by a device (e.g., an electronic device). The storage medium may include random access memory (RAM), a memory buffer, a hard drive, a database, erasable programmable read-only memory (EPROM), electrically erasable read-only memory (EEPROM), read-only memory (ROM), and / or the like.

[0119] Additionally, the processor of the embodiments of this document may call at least one instruction among one or more instructions stored from a storage medium and execute it. This enables the device to operate to perform at least one function according to at least one called instruction. Such one or more instructions may include code generated by a compiler or code that can be executed by an interpreter. The processor may be a general-purpose processor, a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), a Digital Signal Processor (DSP), and / or the like.

[0120] A device-readable storage medium may be provided in the form of a non-transitory storage medium. Here, 'non-transitory' simply means that the storage medium is a tangible device and does not contain signals (e.g., electromagnetic waves), and this term does not distinguish between cases where data is stored semi-permanently and cases where it is stored temporarily.

[0121] Methods according to the various embodiments disclosed in this document may be provided as part of a computer program product. The computer program product may be traded between a seller and a buyer as a product. The computer program product may be distributed in the form of a device-readable storage medium (e.g., compact disc read-only memory (CD-ROM)), or distributed online (e.g., download or upload) through an application store (e.g., Play Store) or directly between two user devices (e.g., smartphones). In the case of online distribution, at least a portion of the computer program product may be temporarily stored or temporarily created on a device-readable storage medium, such as a manufacturer's server, an application store's server, or the server's memory.

[0122] According to various embodiments, each component of the described components (e.g., module, program, user, target, etc.) may include a singular or multiple entities. According to various embodiments, one or more of the aforementioned components or operations may be omitted, or one or more other components or operations may be added. Generally or additionally, multiple components may be integrated into a single component. In this case, the integrated component may perform one or more functions of each of the multiple components in the same or similar manner as they were performed by the corresponding component among the multiple components prior to integration. According to various embodiments, operations performed by a module, program, or other component may be executed sequentially, in parallel, iteratively, or heuristically; one or more of the operations may be executed in a different order; may be omitted; or one or more other operations may be added. Explanation of the symbols

[0123] 10: Processor 20: Network Interface 30: Memory 40: Storage 41: Computer program 100: Service Server 200: Designer Terminal 300: Period server

Claims

Claim 1 A method for supporting a server, comprising a processor, a network interface, memory, storage, and a data bus, to modify an insurance design plan so as not to violate guidelines, comprising: (a) a step in which the server generates each guideline entry and stores it in a guideline database by using a natural language processing module including a large-scale language model (LLM) to decompose insurance guidelines in the form of unstructured natural language into fields by semantic units containing multiple items required for insurance design review; (b) A step in which the server converts each of the above-mentioned guideline entries into a vector, compares the semantic similarity between the guideline entries to identify pairs of entries where the meaning of the core item is similar but the meaning of the condition item is different as potential conflicts or ambiguities, and transmits the list of identified potential conflicts or ambiguities to the guideline manager interface; (c) A step in which the server receives an insurance plan including one or more coverages and a request to verify whether the insurance plan violates the guidelines; (d) A step in which the server determines whether the insurance plan violates the guidelines by querying one or more guideline entries corresponding to the insurance plan in the guideline database, and determining whether there exists a guideline violated by the insurance plan among the queried guideline entries by comparing each item of the insurance plan with the coverage name, coverage limit, age range, gender condition, and combination restriction condition between coverages of the guideline entries item by item; (e) A step in which, if the server determines that the insurance plan violates the guidelines, in a form including the name of the violated coverage, the coverage amount of the plan, the allowable limit under the guidelines, and the type of violation Step to indicate violations;(f) A step in which the server derives and displays a correction plan to ensure that the insurance plan does not violate the guidelines, wherein the correction plan comprises a plurality of correction plans including: (i) a minimum change plan that adjusts the violated items to within the guideline allowable limit; (ii) a plan to maintain the coverage intent that lowers the coverage amount of the violated coverage and adds new coverage of a similar nature to maintain the total coverage amount; and (iii) a conditional upward plan that indicates that the allowable limit of the coverage is raised when a specific special rider is added, and for each correction plan, the violated items, guideline conditions, and proposed content are displayed together; (g) A step in which the server receives input regarding whether to apply a correction plan selected by the planner among the plurality of correction plans and / or modification details regarding the insurance plan, wherein the selection history and direct modification details are collected as training data for reinforcement learning of a correction plan generation model; (h) A step in which the server modifies the insurance plan based on the input received in step (g), and determines whether the modified insurance plan violates the guidelines, whether the modified coverage amount meets the allowable range, and the newly added A method for verifying and automatically correcting insurance design guidelines, comprising: a step of making a judgment by re-verifying, including whether there is a violation of the linkage conditions and combination restriction conditions of the collateral; and (i) a step in which a server displays the judgment result of the above step (h), wherein if the modified insurance design satisfies all guidelines, a message indicating no guideline violation is displayed, if it still violates one or more guidelines, the violation item and specific details are highlighted, and if a request is received to derive an additional correction plan, the server returns to the above step (f) to present a new correction plan; Claim 2 delete Claim 3 delete Claim 4 delete Claim 5 A server supporting verification of violation of insurance design guidelines and automatic correction, wherein the server comprises a processor, a network interface, memory, storage, and a data bus, and wherein the processor executes instructions for executing a method for verifying violation of insurance design guidelines and supporting automatic correction stored in the memory, wherein the method for verifying violation of insurance design guidelines and supporting automatic correction comprises: (a) a step in which the server generates each guideline entry and stores it in a guideline database by decomposing insurance guideline items in the form of unstructured natural language into fields by semantic units containing multiple items required for insurance design review using a natural language processing module including a large-scale language model (LLM); (b) A step in which the server converts each of the above-mentioned guideline entries into a vector, compares the semantic similarity between the guideline entries to identify pairs of entries where the meaning of the core item is similar but the meaning of the condition item is different as potential conflicts or ambiguities, and transmits the list of identified potential conflicts or ambiguities to the guideline manager interface; (c) A step in which the server receives an insurance plan including one or more coverages and a request to verify whether the insurance plan violates the guidelines; (d) A step in which the server determines whether the insurance plan violates the guidelines by querying one or more guideline entries corresponding to the insurance plan in the guideline database, and determining whether there exists a guideline violated by the insurance plan among the queried guideline entries by comparing each item of the insurance plan with the coverage name, coverage limit, age range, gender condition, and combination restriction condition between coverages of the guideline entries item by item; (e) A step in which, if the server determines that the insurance plan violates the guidelines, in a form including the name of the violated coverage, the coverage amount of the plan, the allowable limit under the guidelines, and the type of violation Step to indicate violations;(f) A step in which the server derives and displays a correction plan to ensure that the insurance plan does not violate the guidelines, wherein the correction plan comprises a plurality of correction plans including: (i) a minimum change plan that adjusts the violated items to within the guideline allowable limit; (ii) a plan to maintain the coverage intent that lowers the coverage amount of the violated coverage and adds new coverage of a similar nature to maintain the total coverage amount; and (iii) a conditional upward plan that indicates that the allowable limit of the coverage is raised when a specific special rider is added, and for each correction plan, the violated items, guideline conditions, and proposed content are displayed together; (g) A step in which the server receives input regarding whether to apply a correction plan selected by the planner among the plurality of correction plans and / or modification details regarding the insurance plan, wherein the selection history and direct modification details are collected as training data for reinforcement learning of a correction plan generation model; (h) A step in which the server modifies the insurance plan based on the input received in step (g), and determines whether the modified insurance plan violates the guidelines, whether the modified coverage amount meets the allowable range, and the newly added A server comprising: (i) a step of making a judgment by re-verifying, including whether there is a violation of the linkage conditions and combination restriction conditions of the collateral; and (i) a step in which the server displays the judgment result of the above step (h), wherein if the above modified insurance design proposal satisfies all guidelines, a message indicating no guideline violation is displayed, if it still violates one or more guidelines, the violation item and specific details are highlighted, and if a request is received to derive an additional correction proposal, the server returns to the above step (f) to present a new correction proposal.

Images