15 posts tagged with "release"

Our April release is a big release and includes capabilities throughout the codebase. We've got brand new capabilities like our Provider System of Record, our new METL Domain Specific Language, our new Rx Data loading wizard and the Extractor Wizard UI, and big improvements to our Claims UI to make it generally available.

New Features and Improvements​

Claims UI is generally available​

We're excited to make the Claims UI generally available with METL 1.14. Improvements include a vastly faster API to fetch claims, a global search that allows you to find any claim in the database, and much more.

New capabilities include:

• Select which claim statuses to see in your queue
• Different edit capability for each status
• Global search in the top navbar (click the magnifying glass) to search for any claim in the database
• Fixes to the UI to support loading any claim
• Every claim now gets its own URL so it's possible to share links with co-workers
• Transparency data section now displays example data
• A dropdown allows you to view and select current or previous claim statuses
• Visual improvements to the display with insured/patient split, provider sections, and corrected sorting in the line items
• Improvements to the HIPAA view display to show the full name and address

Provider System of Record​

It's finally time to make the NPI Registry and PECOS data live in METL. We've had the ability to load these for a while, but documentation has been spotty. We've resolved the documentation gaps and retested the loads. It's now easy to spin up a local provider system of record.

Data sources:

• NPI Registry - All providers that practice medicine in the US must get a National Provider Identifier (NPI). The data in the NPI Registry is expansive, but not always up-to-date since providers aren't required to update it frequently.
• PECOS (Provider Enrollment, Chain, and Ownership). This is the database CMS uses to manage providers who receive Medicare patients. Provider must re-enroll in Medicare annually, so the data in PECOS is often more up-to-date than the data in the NPI Registry

New METL Domain-specific Language​

We're excited to announce a new METL DSL that can be used to define rules for provider contracts, accumulators, and much more. The DSL is designed so it can take advantage of any data in the claim as well as many additional pieces of data that can be joined to the claim. We built the METL DSL for contracts, but we'll also be putting it to work in other areas as well. The syntax of the METL DSL looks a lot like a subset of JavaScript so it'll look familiar to most technical people. But, it's designed to be used as a building block system to make it easy to be used by non-technical people as well.

METL DSL supports:

• Lambdas, e.g. (foo) => foo.
• Call expressions, e.g. foo(bar).
• Binary expressions like foo || bar or foo + bar.
• Parenthesized expressions, e.g. (foo + bar).
• Unary expressions, e.g. !foo, -foo, and +foo.
• Some builtins like true / false / null / undefined
• Equality expressions like foo == bar and foo != bar but not like === and !==.
• Numbers and strings, e.g. "foo" and 1.23 note that numbers only support integers and basic decimals, e.g. no exponents or hexadecimals.
• Builtin functions like:
  • between (takes 3 inputs, first is the value, second is the lower bound, third is the upper bound) and
  • if (takes 3 inputs, first is the condition, second is taken when true, third is taken when false), and
  • isNumber (checks if a string is a valid number).
• Properties on objects, e.g. foo.bar
• Methods on arrays, currently that is foo.map((item) => item * 2), foo.filter((item) => item > 5), and foo.sum().
• The global variable claims is the most important and matches an edi837.Claim.

By design, the METL DSL doesn't support local variables, multiline statements, flow control and plenty of other things. It is not designed to be a general purpose programming language. Instead, it is designed primarily to support rules, filtering and other similar types of use cases.

Patient matching improvements​

We added some capabilities to the patient matching UI to make it easier to identify the file and the TPA that the file came from.

Extractor UI​

The updated Extractor UI Wizard is live. This is a configuration-driven Wizard system which allows us to create and modify Wizards to match the types of data we load. For today, our focus is on Claims, Eligibility and Rx data. The purpose of the Wizard is to make it easy to take an extract from a trading partner and quickly get it loaded to the database.

We've been using the backend features of the wizard for over a year now, so it's been battle-tested and we're excited to bring the UI to production too. For now, the Extractor UI is read-only, but we'll be enabling read-write capability over the next couple of releases.

RX wizard & schema updates​

We've now added support for prescription drug data! This includes the database updates, template updates, and a new wizard to support prescription drugs. We anticipate that the 1.15 release will include prescription drug data loading for the first time.

Enterprise tenant deploy capability​

Our enterprise clients need the ability to deploy multiple client environments in one database. We added that capability in this release.

Extractor templates​

We added some additional features to our extractor input templates. One is that we made it possible to have a CSV column as either a string or an object with additional configuration options. Second, we added a new userFirstMatch option. This is useful for poorly designed data files where the data file repeats the same data in the file more than once.

Before:

optional: [claim_member.member_identification_code]
useFirstMatch: [claim_member.member_identification_code]
csvColumns:
    claim_member.member_identification_code: Subscriber_ID

After:

csvColumns:
    claim_member.member_identification_code:
        name: Subscriber_ID
        useFirstMatch: true
        optional: true
    output1.column2: Value 2 # still works

View improvements​

• line_item_reporting_view - added receive_time
• line_item_everything_view - restored the columns that got incorrectly removed in the v1.9 release

Repricing improvements​

We continue to add new capabilities to our My Price Health repricing engine for our enterprise clients. New capabilities include:

• ZIP3 fallback
• Rate sheet quantity
• Resolve negative Medicare issue
• Invalid SNF claim error message
• Improve ASC provider check

Testing and Deployment​

CI deploy fixes​

In v1.13, we added Atlas tests to verify views are all working. Some views run crosstab to translate rows into columns, so they only fail at runtime. But, the lints don't catch any errors if there is no data. So, with this release, we now run Atlas tests during our test and prod deploys to make sure that all of our views work.

Extract/load race condition​

We solved a timing issue where extracted data would not load because the new release record hadn't yet been created when csvloader attempted to load.

Testing improvements​

We made several internal testing improvements to better validate the code that we release. Most notably is that we're now running unit tests for the web UI as a part of CI.

New openjdk image​

The openjdk image we were previously using is no longer available on Docker Hub so we switched to a newer and more supported Docker image.

Our January release is primarily filled with new capability preparation. We're building out the ability to load Rx data to the database. We're also working on our Extractor UI to dramatically reduce the time it takes to translated data files into the METL schema. And, we're building the METL domain specific language (DSL) to make it easier to handle contract repricing, accumulators, payment integrity, and more.

New features and improvements​

Preparation for new Rx data loading​

We've done a lot of work to prepare for loading prescription drug data to the database.

• Extractor templates moving to the database
• Rx Schema
  • rename Go struct fields
  • update DB schema

Jobs UI​

The Jobs UI has turned out to be an very helpful tool to easily view and troubleshoot load issues. We continue expanding and improving it with:

• Enable searching for only failed jobs
• Fix paging

Claims repricing workflow improvements​

Enable adding new claim status through API

Working on METL Domain Specific Language​

METL DSL MVP. This will unlock capabilities for contracts, accumulators, payment integrity and much more.

Enterprise tenant deployment​

We've enabled the METL web UI for our enterprise tenants.

Other various enhancements​

• Switch to govalues/decimal. We now use this for all decimals instead of the previous decimal package we used which took much more memory.
• Add member_canonical_id_chosen to views so we can take advantage of patient matching data
• More line item categories for grouping for better reporting
• Rename columns with "_id" that aren't key columns for clearer usage
• Make patient matching more deterministic for better comparison and consistency
• Use claim_number as the standard claim number instead of payer_claim_number for better clarity and consistency.

Testing and Deployment​

• Automated Python package publishing via GitHub Actions
• Fixes to make it easier to release Python package

Our December release is a little bit light as we shaved a week off the development schedule in order to get us closer to our monthly release cadence timeframe. Our plan for 2026 is to release the first Wednesday of every month.

UI​

Job status dashboard​

Fixed the proxy to pass query parameters so that the jobs search and pagination works correctly now.

extractor wizard​

Database schema is included in this release. More progress towards full read/write capability for new extractor templates.

System updates and improvements​

We made several fixes to our user authentication and role management system for our tenants. We now have the ability to configure roles per tenant instance.

The METL UI is finally here for all users! This brings a claims UI, a job status dashboard, manual member matching, and the extractor wizard.

UI rollout​

Claims UI​

View HCFA and UB-04 claims in the claims UI to see all the claims in the database. Views include a PDF view of both HCFA and UB-04 claims as well as an HTML view with additional features such as repricing information.

Job status dashboard​

View the status of all data loads. You can see the times, statuses, and logs of both the extractor and csvloader steps.

Manual member matching​

Choose what to do with eligibility members and claim patients which have not been able to be automatically matched to a canonical member.

extractor wizard​

View the mapping between all the columns in a data file and the fields in the database.

System updates and improvements​

In addition to the exciting features in the UI, this release also includes a gateway / proxy server for backend API calls on AWS and other environments, as well as fixes for authentication and user roles.

This release also ended up being a great time for us to migrate from Svelte 4 to Svelte 5 to take advantage of the new capabilities.

X12 EDI 837 loading and repricing​

X12 EDI 837 Data loading is now ready for production. We've loaded EDI files from many different TPA's as well as repricing data for each. EDI data is now the easiest way to get claims data into the METL database.

Member matching improvements​

We continued the performance improvements of the v1.10 release. This release now does member matching more efficiently than before.

The top new feature in v1.10 is the extractor wizard. This brings forward our vision for making it easy to import common data (currently claims and eligibility data) in different formats into METL. Other exciting improvements include the beta version of our X12 837 EDI data loading, other data loading, and some important improvements to prepare for our fully open source future.

extractor Wizard​

With v1.10, we enable read-only access to all extractor claims and eligibility templates. This allows you to drop a file onto the web UI and view the extractor field mapping. You can't update the configuration at this time. The wizard is expected to allow for editable configuration in the v1.12 release, enabling rapid iteration to load data. The vision of the wizard is that teams will be able to get new data from a trading partner and configure and load it the same day.

Member matching performance fixes​

While member matching performance was great in our testing, it didn't fare so well on the larger databases of our customers. This release adds some fixes to improve performance including:

• Query fixes: this is the biggest performance fix. The query change was HUGE. It went from 8 1/2 hours to 4 seconds. Bizarrely, there was no change to the functionality of the query. We had an OR condition in the query to get both scenarios. That OR condition caused it to go 8 1/2 hours. We switched it to two separate updates without an OR condition and it became 4 seconds.
• Vacuum and analyze as needed: Early on, we added a vacuum and analyze to extractor after tables were updated. This fixed massive performance issues by ensuring that statistics were always up to date. Unfortunately, this came at the cost of running these operations after every load. This improvement changed this operation to only run after the number of rows in a table changed by enough to need a re-analyze. This shaves a few seconds off every load.

X12 EDI 837 data loading beta​

Improvements to 837 EDI loading. We've now extracted and loaded nearly 2000 different EDI files in our testing. Loads are working well, and we expect the prod release to be v1.11.

Other system improvements​

As we continue marching toward our full Open Source release, we're improving our systems to comprehend the capabilities we need to balance rapid iteration and a tighter feedback loop from our customers. Improvements this release include:

• Python client CI and testing.
• Database deploy CI fixes
• JOSH (just one single history). This is the tool we've been needing to allow us to open source METL and be able to receive pull requests from the public repository and also push code from the internal repository. This gets us much closer to being able to fully Open Source METL.
• METL archives with hashes. Rather than using dates, we're now using hashes. This ensures that we don't save the same exact file over and over to S3
• Removed dependency on Microsoft Office email client which was causing the Web server for the Claims UI to not start

The headline features in version 1.9 are member matching and X12 EDI 837 claims loading. Other improvements include a provider system of record (in preparation for future provider matching), address parsing and normalization (in support of member and provider matching), improved telemetry (to help us better solve performance issues), reporting lookup data improvements, extractor improvements, and the first step towards deploying the METL website publicly.

Member matching​

Humans are complicated. We move from one place to another. We change our last and first names. We change gender markers. Not only that, but trading partners routinely make errors entering member information. So, we even see changes in date of birth, member IDs, and Social Security Numbers. Because of this, member matching requires a considerable amount of fuzzy matching. While humans are really good at fuzzy matching, computers, in general, are not. v1.9 introduces automated and human-assisted member matching that seeks to identify a human being, even across multiple trading partners. Member matching will track me across all of these sorts of scenarios, and many more:

• I change employers and my new employer happens to use the same TPA as my old employer. I'll get a new member identification code on my insurance card, but the records will be merged into a single canonical member.
• I have insurance from my employer and also through my spouse's insurance at the same time. Even though I have two insurance plans at the same time, both will show as the same canonical member ID.
• I change my name and address, but have the same SSN.

Automated matching is a rules-based algorithm that matches members together when there is a high degree of confidence that they are the same. In our testing, we can automatically handle about 97% of cases, and humans need to review the remaining 3%. This is a critical capability to enable a bunch of use cases we have plans for in the future including member-level reporting and risk analysis, member-specific data access (in a future member UI) and much more.

X12 EDI 837 claims data loading and repricing​

We're excited to be able to bring X12 EDI 837 claims data loading and repricing to METL. This is an alpha release and is being tested internally, but will launch publicly later this year. The X12 EDI specification makes it possible for us to load data from multiple trading partners without managing a whole host of data import scripts for each TPA. And, since the X12 format is the HIPAA standard, it's the most ubiquitous format for healthcare claims data. v1.9 brings the capability to load this to the database and adds the data tables necessary to store all the repricing benchmark data that My Price Health supplies to customers in their API. In a future release, licensed X12 customers will be able to load X12 data directly to the database. For customers that want their data repriced to a contract or using some other methodology, METL will call the My Price Health API to reprice the data automatically on load.

This is our first METL plug-in that brings enhanced functionality to the platform for licensed users. Licensed users will not need to send their data off through SFTP to have this work performed for them, but METL will orchestrate the work directly in the METL platform. We're excited to use this same model for other METL plugins in the future. We believe this can greatly speed up claims processing and payment.

Supporting improvements​

Provider System of Record​

We are continuing our work to enable provider matching. This is a similar problem as the aforementioned member matching problem, but for healthcare providers. To begin with, we're building a system of record of healthcare providers. We're merging together multiple data sources to create a single master record for providers. We expect to continue to add additional data sources to this over time, but this release brings us new or updated data from these sources:

• NPI registry
• PECOS enrollment
• Doctors & Clinicians National Downloadable File

Address parsing and normalization​

One of the challenges of fuzzy matching for providers and members is that addresses are messy. For example, all of these are the same address:

• 1234 West Main Street Apartment 6B
• 1234 W Main Apt #6B
• 1234 W Main St Apt 6B

We've tried out a handful of address matching tools over the years. We then wrote our own when none of the tools we found were perfect. The focus of our address parsing and normalization tool was to be fast and simple. It first attempts to parse an address, and then it attempts to normalize it. If all goes well, all the above address variations above (and more) end up in the database as a single canonical address.

Reporting data lookup tables​

We're adding additional data to support reporting and analysis including:

• Procedure code lookup improvements
• Procedure code group fallback
• HCUP diagnosis chronic condition indicators

Improved telemetry​

We ran into several performance issues with member matching once we ran it on a large database. To sort the issues out, we added telemetry in AWS and in the database to make it easier to track down the issues.

extractor improvements​

We made a few improvements to extractor and csvloader to support optional loads. This is important since not all columns are always present, and not all files are present to load either. This gives us the flexibility we need for input files that change over time.

We're excited to announce version 1.8 of METL!

The main public user-facing features of 1.8 are data fixes for a number of data loads that were released previously and the metl.dev website (this documentation)! We have enabled documentation by dynamically reading the latest Atlas .HCL files, so it should be simple to keep the documentation up to date each release.

While not yet public, this release also adds a UI to METL! It's being tested and should land in the 1.9 version of METL for general usage. The UI includes 2 different views of claims data (PDF view and HTML view), a demo of the upcoming extractor wizard, a demo of the manual patient matching functionality and more. In addition to claims data, the UI also includes Transparency in Coverage (TiC) data for each claim to provide a sense of contract rates for different carriers and TPA's.

We're excited to announce version 1.7 of METL!

This release adds several new lookup tables that assist in reporting, data analysis, and even typical transactional claims processing, a bunch of foundational features that will be enabled in future releases, and some other data improvements surrounding EDI 837 claim storage.

What's new?​

New lookup data​

1. Horizon Blue Cross Case Management trigger list.
2. CPT hierarchy.
3. ICD diagnosis hierarchy.
4. ICD procedure hierarchy.
5. JHU wasteful drugs lookup.
6. Bill Type to Place of Service crosswalk.
7. Place of Service groups.
8. Stop loss trigger diagnosis codes.

Other table changes​

1. Remove deprecated name, contact_seen, name_given, provider_identification, member_identification, member_member_eligibility, and claim_member_match tables.
2. Updates to the claim table to align the database and the EDI 837 parsing.

New tables to support upcoming features​

1. member_canonical table. This replaces the member table and represents a canonical human represented ideally by a unique SSN number.
2. name_given_alias, claim_member_to_member_seen_match and member_seen_to_member_seen_match. These tables are used for patient matching between eligibility loads and from claim to eligibility data. They are used for both manual and automated patient matching.

Version 1.6 of METL has arrived!

This release adds a bunch of new data loads, improves view and data loading performance, adds additional type safety with PGGen and adds initial capability upon which we will be building out patient and provider matching.

New Features​

• Table updates to support the rest of the EDI 837 spec. This makes it much easier to query all types of data in the database since each field now has columns and rows rather than JSON fields.
• Table updates to support patient and provider matching. We're building our matching UI based on these tables.
• Performance improvements to views, tables and queries: Now takes about 1/2 the time to load member data through the member views in our environment due to fewer and simpler joins.
• PGGen - we were originally planning to do GraphQL for our API engine, but couldn't find a good solution that fully met our goals. We chose PGGen instead which will ensure the same sort of query safety and ease of use through an API. Our current API has been converted to use PGGen and it is working well for us.
• Update to csvloader to run analyze after loading data so that loads don't continue to slow down as new data gets added. Previously, the only way that statistics were updated was through AWS automated tools that didn't always run at the ideal times, making loading slower.

Bug fixes​

• NULL solution name error on empty input files has been made more clear.

Patch releases​

1.6.1​

Migration fix for claim_member. Previously the migration was not generating a unique list of correct IDs based on the new primary key which caused some migrations to fail.

1.6.2​

Fix for member_eligibility_current_view to correctly include all members after the switch to using trading_partner_submission table instead of eligibility_submission.

1.6.3​

Update migration for Health Rosetta.

1.6.4​

Migration fix.

1.6.5​

Migration fix.

The 1.5 release has arrived!

While this release brought important new data loads and additional features, it was never deployed outside of My Price Health.

Not released version​

• This version was never deployed outside of My Price Health due to an issue. See version 1.6 which fixed this issue and added additional features