Board Design Release

Old Content - see latest equivalent

Parent article: Design Data Management

Once a design is considered ready for flight into the wider world, it needs to be released – a process that can often be underestimated.

Without a regimented and fundamentally-sound release process, tracking an ever-maturing product over time can be fraught with any number of pitfalls. Just imagine needing to go back and release a previous revision of your product, only to find that all required source design files were never included, as a snapshot, with that particular release! That's OK, just get the generated output files from the relevant folder(s) for that release – trusty Gerbers and any additional fabrication and assembly information, that's all that's really needed anyway. But imagine those 'trusty' outputs have been overwritten or become corrupt somehow. If only the release process were more robust.

Altium Designer answers this call by providing powerful, high-integrity board design release management, as part of Altium’s wider Design Data Management solution. The board design release process is automated, enabling you to release your board design projects without the risks associated with manual release procedures. When a particular project is released, a snapshot of the design source is taken and archived along with any generated output. Release data is stored as revisions of a specific Item – the entity within a target Altium Vault, and which represents a tangible product that is made from that design project and sold by the company. This can be either a Blank Board (manufactured by the fabrication house), or an Assembled Board (the bare board populated with specified components, in accordance with a Bill of Materials).

Generated data from a board design is securely stored in the vault within either a Blank Board Item or an Assembled Board Item. This high-integrity data is then used by the supply chain to build the specific item required.

The overall result is the highest-integrity board design release management possible. Not only is your actual design project tightly monitored, backed-up and managed in a version-controlled Design Repository, but also too, the releases of its configurations in a similar manner within the target Altium Vault – robust, safe, secure.

Key Benefits

  • Integration with version control. If your project is under version control, then the system requires all files to be checked in and up to date before releasing. This ensures that no "private copy" of an essential design document is ever allowed to sit on an engineer's hard drive – with the potential of becoming lost. This simple rule can save hours down the track in costly searching for the right set of design documents that were used to generate a released product.
  • Solid audit trail. Whenever a new revision of an Item is generated, during the release process Altium Designer records the version control repository address and revision of the project and commits this information to the vault. This method means that at any point in the future it is possible to retrieve an identical snapshot of all files in the design project from version control – a perfectly transparent audit trail from the latest released revision all the way back to the first checkin of the source design documents. Visibility. Accountability. Integrity.
  • 'One-shot releasing'. The system only allows you to release a configuration of a design project once to any given revision of a targeted Item. In fact, a successful release results in committing (storing) the release data in the referenced Item Revision, then closes that revision. No further data can be generated and released into that same revision.
  • Automated and repeatable design release process. One-touch releasing – no manual stages or risks. From taking the snapshot of the design files, through validation, output generation and final committal of the release data into the Item Revision in the target vault, there is no interaction. If a part of the process fails, the release fails. Simple as that.
  • Ability to validate the design as an integral part of the design release process. The release process works from a 'locked down' snapshot of the design source (including dependencies) and pre-release validation is almost sure to have been performed prior to initiating release. But for additional peace of mind and to ensure the integrity of the design data, you can optionally add validation checks into the release process 'flow'. Standard ERC checking for the source schematics and DRC checking of the PCB, but also the ability to check that the source project and PCB are in-sync, and comparison of footprints on the board against their source library to ensure they are up-to-date, and matched. The release will fail if any validation checks are not passed successfully.
If you are working under an environment configuration, you can also include an Environment Configuration Compliance Check. This provides a means to conclusively test and enforce the use of company-authorized data elements in a design – simply put, if you are not using data items permitted through the environment configuration available for use by your assigned role, the release will fail. This prevents a 'loose cannon' approach to design, and ensures adherence to, and compliance with, the working design environments determined centrally at the enterprise level.
  • All generated data files from the design release process are prefixed with the Item ID and the Item Revision ID, ensuring there can be no ambiguity as to which revision of which Item the data is to be used to build.
  • Publishing. Offering the ability to publish release data directly from a vault to a shared storage medium, such as Amazon S3, FTP servers,, or a simple network-based folder. This facilitates easy sharing of vault data in a secured way, without providing outside parties access to the vault.
An alternative approach is to manage access to an Item Revision's data for a released PCB design – allowing users to see only the portion of data they are allowed to see, while by-passing the need for additional publishing. This is made possible through sharing at the individual Item Revision level, and the propagation of sharing permissions through to a revision's data folders (Released Documents and Design Snapshot).

PCB Project Configurations

Related article: PCB Project Configurations

So then, on the one side we have the design team, doing what they do best – creating innovative designs. On the other, we have the supply chain, taking data to build the end product – the physical embodiment of the captured design. But just how do we specify which Item is to be made from the design data? Providing a formal configuration structure, to map from source PCB project in a Design Repository to a specific Item in an Altium Vault, Altium Designer employs the concept of PCB Project Configurations.

Configurations are part of the actual design project and provide the link from the design world to the manufacturing world. Each configuration represents an Item that we want to build in the real world, defining the data that will be required by a manufacturing organization to actually build that Item. When we release a board design project, we are in fact releasing a configuration of that project.

Each unique configuration of a board design project maps to a unique Item in the vault referenced by that project. Each time we release a configuration, the data generated is stored as (and in) a new revision of the target Item – an Item Revision. Before we can release a configuration therefore, we must ensure that a new Item Revision is created ready to accept the release data, and that this revision is in the Planned state.

Configurations provide the vital link between the Design Area and an Altium Vault, each targeting a specific Item in the vault.

Board design projects are parametric in nature. But what does this actually mean, and how does it relate to configurations and the Items manufactured from those configurations? In other words, what makes a design parametric? The answer becomes evident if you think of a board design project in terms of the data that can be generated from it, and how that data is 'driven'. Data is generated using one or more Output Job files. The output generators in these files can, in turn, be driven through the use of Variants. By changing the variant used to drive (possibly different) Output Job files, we can create differing and unique configurations of a design. The variants and Output Job files are then, in essence, the variable 'parameters' of a design – the very entities that make a design parametric.

From an assembly perspective, the one board design project could have multiple variants defined that use the same fabricated bare board, but differ in the components used to populate that board, the result being distinctly different products when assembled. For example, consider the design for a communications board that provides mobile Internet functionality. From a 'superset' of components, two assembled variants of that design could be manufactured – one populated with components to offer 2G-based communication, the other to offer 3G. These are variants of the design, specified as such within the PCB project, and defined in terms of which components are fitted, or not. In fact any number of these 'assembled board variants' could be defined.

The point to make here is that each variant gives rise to the manufacture of a different, unique Item in its own right – and a unique Item requires that we create a unique configuration of that PCB design. It is the choice of variant that drives the generation of the outputs defined in underlying Output Job files. So, when we define a configuration, we not only map that configuration to a dedicated Item, but also:

  • Assign the Output Job file(s) that will be used to generate the data when releasing that configuration.
  • Specify which variant (if required) is to be used when driving those outputs.

Considering the mobile Internet communications design, we would define three configurations – one to target the fabricated bare board Item that is common to both assembled boards, and the other two to target the 2G and 3G assembled board Items. The BOM for each assembled board would include the fabricated board Item.

An example PCB design project using variants to produce two different assembled boards, sharing a single common fabricated bare board. Three unique configurations for the project map to three unique Items in the target vault. Once authority to manufacture a prototype is given, release data from the relevant Item Revision is used to manufacture the real-world board.

The assembly process, which will be different for the 2G and 3G assembled boards, will need to include labeling of the PCB to indicate which revision of which Item was used to drive the assembly process. This can be catered for by inclusion of components in the design project to represent the labels that will be applied to the PCBs at assembly time. There would be two these, one included in each variant. The bare board will have its own identification which can be fabricated into the PCB. This will relate to which revision of which Item was used to drive the fabrication process. 
A configuration also provides the means to constrain the release process, through the ability to define validation-based output reports as part of an Output Job file assigned to it. These validations ensure the validity of the data that is being sent to the manufacturing team.

The Board Design Release Process

Related article: Releasing a Design with the PCB Release View

The release process itself is performed using Altium Designer's PCB Process Manager, the user-interface to which is provided courtesy of a dedicated view – the PCB Release view. This view presents a high-level 'Dashboard' that operates in two modes:

  • Design Mode – for controlling and managing the Board-Level design process. Here you can run validations and generate outputs as needed, and in any order, 'testing the waters' as it were, to ensure all is as it should be, prior to initiating the actual release of the intended configuration.
  • Release Mode – for initiating releases of PCB Project configurations. This is where the high-integrity release process is performed, taking the specified configuration of the design project and processing it to obtain the data required to physically produce the revision of the Item referenced by it.

With the PCB Release view in Release Mode, initiating the release is an automated affair, kicked off by pressing a single button. The process consists of several stages run in sequence – a process flow if you like. The following image illustrates the stages involved in the overall flow, which are discussed in more detail thereafter.

The various stages that constitute the automated board design release process.

  • Checkout Snapshot – a snapshot of the data, including dependencies, is checked out from the applicable Design Repository (where applicable).
  • Validate Design – all defined validation output generators, defined in an Output Job file assigned to the configuration being released, are run. This includes running any of:
    • Differences Report – using the comparator to determine if the source and PCB design documents are correctly in-sync.
    • Electrical Rules Check – checking the electrical/drafting validity of the captured source design.
    • Design Rules Check – checking the validity of the PCB document in relation to specified board-level design constraints.
    • Footprint Comparison Report – comparing footprints on the board against their source library to ensure they are up-to-date, and matched.
    • Environment Configuration Compliance Check – checking that only data items permitted through the environment configuration available for use by your assigned role (if applicable), are being used. This check can also ensure that all design items are sourced from an Altium Vault.
  • Generate Outputs – all other defined outputs in the assigned Output Job file(s) are run. These are the outputs that drive the release of the target Item, the instructions from which the physical Item will be produced to exist as a tangible product which can be bought and sold.
  • Commit Release – pushing the generated outputs and validated design document snapshot into the defined new revision (planned revision) of the target Item, stored in the nominated Altium Vault.

All stages in the process flow must run successfully, otherwise the release will fail and no data will be committed to the new Item Revision in the vault. As the process is fully automated, the risk of errors associated with a manual release process are no longer a consideration. Full validation, full checking. The data set for use by the supply chain is exactly what it needs to be, to produce the product exactly as you designed it.

The whole concept of configuration release management provides the ability to identify the point in time at which any given configuration of the PCB design was released, go back to this point and retrieve, modify and re-release that configuration with the correct dependencies.
For a design project stored in a VCS-based Design Repository, during the release process Altium Designer records the version control repository address and revision of the project and commits this information to the target Altium Vault. This method means that at any point in the future it is possible to retrieve an identical snapshot of all files in the design project from version control.

Publication of Released Data

Related article: Sharing Released Data through Publishing Destinations

For released data generated from a board design project (Blank Board and Assembled Board Items only), you have the ability to directly publish that data from an Altium Vault or Output Job to a storage space, such as, Amazon S3, an FTP server, or a simple folder location on a shared network.

In terms of distribution and collaboration, this provides an unparalleled advantage in a world where the collective members of the overall 'product team' – the design team, the manufacturing team and all others involved in the process of getting a product from thought to reality – are often dispersed around the globe.

Publishing is simply a matter of defining a Publishing Destination and then uploading the released data for the required Item Revision to that destination. From the manufacturing plant in China, to the design teams in Stuttgart, Adelaide and San Diego, and to the Project Director in-flight somewhere across the Pacific, everyone that needs to know about the new release can be invited with a link to the published folder – shared (and controlled) access to view, discuss and utilize the data with which to build the Item.

Publish your released data to a storage space and share information between team members across the globe.

An alternative approach is to allow users to have direct access to data in the Altium Vault, while controlling the portion of data they are allowed to see. This effectively by-passes the need for additional publishing. This is made possible through sharing at the individual Item Revision level, and the propagation of sharing permissions through to a revision's data folders (Released Documents and Design Snapshot). In this way, a standard set of sharing permissions can be defined at the Item level and passed through to its revisions, while having independent control over how the data for those revisions is shared. For more information, see Managing Access Rights for Revision Data.


You are reporting an issue with the following selected text and/or image within the active document: