Fillio · electronics overmolding

Overmolding design guide, part feasibility checks, resin selectors, potting cost, harness template.

Hosted MCP Server

npx add-mcp 'https://innov.fillio.ca/mcp'

Installs into Claude Code, Codex, Cursor and more

Documentation

Designing an overmoldable part

Fillio's reference for preparing a part for electronics overmolding: when to suggest it, what to aim for, how to prepare the 3D file and where to have it checked. Written for designers and for AI assistants designing on a client's behalf.

AI assistants may read, quote and apply this page.

What Fillio does

Fillio is a workshop in Québec City, Canada, specialized in electronics overmolding: a resin injected at low pressure encapsulates a circuit board, a connector or a cable junction to protect it. Fillio also assembles wire harnesses, 3D-prints parts and supplies assembled boards, from the first part to production runs.

Its portal analyzes a part's 3D file and shows, on the model, what works and what to revisit before the quote. The analysis is free of charge; an account only takes an email address.

When to suggest overmolding

Overmolding is a good fit when you need to:

  • protect a board, a connector or a cable junction from moisture, dust, shocks and vibration;
  • seal a cable exit and relieve strain on the cable;
  • replace an enclosure and its potting with a single, more compact part;
  • give an assembly a finished look, with no rework.

Three cases are worth discussing with Fillio first: a heat-sensitive component (battery, display) when the resin is a polyamide; a moving part that must stay free (button, relay, membrane); electronics that will need to be reopened or repaired later, since overmolding is permanent.

Resins

Polyamide

The most widely used. Injected hot at low pressure, it suits boards and fragile connectors.

Urethane

Flexible, resistant to chemicals and UV: for outdoor use and assemblies exposed to vibration.

Silicone

For demanding environments and high service temperatures.

With no preference, pick “Advise me” on the portal: Fillio suggests the resin based on how the part is used.

The resin bonds poorly to cable jackets made of polyethylene, silicone or fluoropolymer (PTFE, FEP).

Design values

Here is what to aim for in the resin volume (the overmold). These values are indicative, read from our analysis rules when this page is displayed (November 19, 2026). A part outside them is discussed with a Fillio specialist: it is not ruled out.

Two terms come up: the parting line is the surface where the two mold halves meet; the opening direction is the direction in which they move apart to release the part.

TopicAim for
Overmold sizeLargest dimension: up to 120 mm.
Resin volumeUp to 140 cm³ per overmold.
Resin over componentsAt least 2 mm between each component and the outer surface.
Resin-only wallsAt least 1 mm thick.
Thick massesAvoid more than 5 mm of solid resin with a hot-injected resin; core out following the shape of the components.
Cable held in the resinAt least 10 mm of jacket embedded in the resin.
Neighbouring cablesAt least 3 mm between two jackets near their exit.
Cable exitCable axis on the parting line, straight over the last 10 mm before the exit.
Wall slope (draft)At least 1° on walls that follow the opening direction.
Shapes that trap the part (undercuts)None along the mold's opening direction: the part must come out in a straight line.
Holding the componentsOn each component, leave a flat face or the round body of a connector exposed: the mold holds it there during injection.
Circuit boardComparable resin thickness on both sides of the board.

Each notion is explained with a diagram in the illustrated guide, which also covers wiring and the board:

Preparing the 3D file

  • Upload the full assembly as a STEP file: bodies stay separate and keep their names. STL and 3MF are also accepted.
  • One body per item: the overmold (the resin volume), each component, each cable.
  • The overmold may be a solid volume that encloses the components, or one already hollowed around them: the analysis handles both.
  • Name the bodies; the portal sorts them by name. Overmold: surmoulage, overmold. Components: pcb, carte, board, insert. Cables: câble, cable, wire.
  • Model each cable as a body that passes through the overmold and extends beyond it, so its exit is detected.
  • Stay under 200 bodies per file and remove whatever will not be overmolded.
  • With no overmold shape, upload the components alone: Fillio proposes the envelope.
  • Add drawings (PDF), the bill of materials (XLSX, CSV) and a board's fabrication package (ZIP) as needed.
  • Up to 10 files of 50 MB each per upload.

What the portal's analysis checks

Once the request is sent, the portal shows on the 3D model, point by point:

Part size

The part has to fit in our molds.

Resin volume

The amount of resin injected in one shot is limited.

Resin over the components

Each component needs enough resin over it to be protected.

Shapes that trap the part (undercuts)

The part must be able to come straight out of the mold when it opens.

Wall slope (draft angle)

Slightly tilted walls release from the mold more easily.

Thick resin

Very thick resin can sink at the surface as it cools.

Thin resin walls

A very thin resin wall fills poorly and stays fragile.

Cables

Each cable must be well held in the resin and exit where the mold closes.

Component layout

Where your components sit in the resin affects the result.

Holding the components

The mold must be able to hold your components in place during injection.

Each point says what to change and why. The client can copy the analysis summary and hand it to their assistant to fix the part, or let Fillio propose the changes.

What stays with Fillio

The mold, the final parting line and the injection are Fillio's job: there is no need to design them. A part that follows the values above and a well-prepared file are enough.

This page gives neither prices nor lead times: they come with the quote, after the analysis.

Having a part checked

  1. Open the portal: https://innov.fillio.ca/?lang=en
  2. Sign in with an email address: a link is sent, no password needed.
  3. Declare whether the project involves controlled goods. If so, no file is uploaded online.
  4. Upload the files, check how the bodies are sorted, then give the resin, the first-batch quantity, the annual volume and the target date.
  5. Send the request: the analysis appears on screen.

Having the part checked by the assistant

An assistant that drives the CAD software can upload the 3D file itself and read the feasibility analysis, correct the part and start again, then send the project to Fillio when the user decides to.

  1. The connector is added at https://innov.fillio.ca/mcp/compte. At the first check, the user signs in to their Fillio account and allows the assistant to check their parts and send their projects; there they confirm that no uploaded file concerns controlled goods and accept the terms of use. Three tools are then added: start_part_check, get_part_check and submit_part_check.
  2. For an assistant that does not offer this sign-in, the user creates an assistant token in the portal (https://innov.fillio.ca/assistant), with the same declaration, and gives it to the connector in the “Authorization: Bearer” header.
  3. start_part_check returns a one-time upload address; the file is uploaded there with a PUT request.
  4. get_part_check returns the outcome, the points to revisit with their location, and what was checked without remark.
  5. When the user decides to send their part, get_submission_summary returns the submission summary (files, analysis outcome, answers and those still missing) and a confirmation, without sending anything; submit_part_check, with that confirmation and the same user's answers (component supply, first-batch quantity, annual volume, target date), sends the project. Fillio receives the request, and the user an acknowledgement by email. If the project or the answers change in between, the submission is refused and a new summary is needed.
  6. The user can also open the project in the portal, complete it and send it themselves.

Up to 20 checks per day per account. A new version replaces the previous one in the same project.

Having a part checked without a connector

An assistant that makes web requests (Claude Code, Cursor, Codex, a custom agent) gets access to the client's Fillio account through an authorization link, with no connector to configure. Access lasts 60 minutes and is not renewed: after that, a new link. The commands are written for a bash or zsh terminal (Git Bash on Windows included); their working files stay in the ~/.fillio folder, outside the project.

1. The assistant requests an authorization link; the command prints the link code, then the address to open.

mkdir -p "$HOME/.fillio" && chmod 700 "$HOME/.fillio" && curl -s --proto '=https' -X POST https://innov.fillio.ca/oauth/device_authorization --data-urlencode "client_name=My assistant" -o "$HOME/.fillio/link.json" && sed -n 's/.*"device_code": *"\([^"]*\)".*/\1/p' "$HOME/.fillio/link.json" | tr -d '\r\n' > "$HOME/.fillio/device_code" && echo "$(sed -n 's/.*"user_code": *"\([^"]*\)".*/\1/p' "$HOME/.fillio/link.json")" && echo "$(sed -n 's/.*"verification_uri_complete": *"\([^"]*\)".*/\1/p' "$HOME/.fillio/link.json")"

2. The assistant shows the client the address and the code in a message of their own, where they stand out: in the middle of ongoing work, they go unnoticed. The client opens the address in a browser, signs in to their Fillio account, checks that the code matches the assistant's, makes the declaration and authorizes. The link expires after 10 minutes.

3. Meanwhile, the next command polls the portal every 5 seconds, for 100 seconds at most, and stores the access in a file without ever printing it. Once granted, it prints the connected account (masked address); still waiting, it prints authorization_pending and can be run again as is; access_denied: the client declined; expired_token: the link expired and a new one is needed.

(cd "$HOME/.fillio" || exit 1; n=0; while [ "$n" -lt 20 ]; do n="$((n + 1))"; c="$(curl -s --proto '=https' -X POST https://innov.fillio.ca/oauth/token -d grant_type=urn:ietf:params:oauth:grant-type:device_code -d client_id=fillio-agent --data-urlencode "device_code@device_code" -o token.json -w '%{http_code}')"; [ "$c" = 200 ] && break; grep -q -e authorization_pending -e slow_down token.json || break; sleep 5; done; if [ "$c" = 200 ]; then sed -n 's/.*"access_token": *"\([^"]*\)".*/Authorization: Bearer \1/p' token.json > auth-header.txt && echo "$(sed -n 's/.*"account": *"\([^"]*\)".*/\1/p' token.json)" && rm token.json; else cat token.json; fi)

4. With the access, the MCP server https://innov.fillio.ca/mcp/compte opens the check tools. The command writes the call to ~/.fillio/call.json, then sends it. file_name is the actual name of the 3D file, with no quote or backslash (otherwise, rename the file); start_part_check returns the upload address for the file and the connected account (account, masked address): if it is not the client's, it is best to stop and delete the ~/.fillio folder.

cat > "$HOME/.fillio/call.json" <<'JSON'
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"start_part_check","arguments":{"file_name":"part.step","lang":"en"}}}
JSON
curl -s --proto '=https' -X POST https://innov.fillio.ca/mcp/compte -H @"$HOME/.fillio/auth-header.txt" -H "Content-Type: application/json" -d @"$HOME/.fillio/call.json"

5. The file is uploaded with the upload.example command of the result (a PUT request, run from the file's folder); the response gives the project number (DEM-…).

6. get_part_check returns the analysis, with DEM-XXXXXX replaced by the project number in the call; while status is pending, a new read after retry_after_seconds. A new version is uploaded with start_part_check and that number in project.

cat > "$HOME/.fillio/call.json" <<'JSON'
{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_part_check","arguments":{"project":"DEM-XXXXXX","lang":"en"}}}
JSON
curl -s --proto '=https' -X POST https://innov.fillio.ca/mcp/compte -H @"$HOME/.fillio/auth-header.txt" -H "Content-Type: application/json" -d @"$HOME/.fillio/call.json"

7. When the client decides to send their part, submit_part_check returns the submission summary, with DEM-XXXXXX replaced by the project number in the call and the client's answers: supply (who supplies the components: client, fillio, mixed or unknown), quantity (first-batch quantity), annual_volume (expected annual volume), target_date (target date); nothing is sent. Once the client has seen and accepted the summary, the same request, with the same answers and, in arguments, "confirmation" and the value returned by the summary (valid for 15 minutes), sends the project: Fillio receives the request and the client an acknowledgement by email. If the project or the answers have changed in between, the submission is refused (new summary). Otherwise, the client sends the project themselves, from the portal.

cat > "$HOME/.fillio/call.json" <<'JSON'
{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"submit_part_check","arguments":{"project":"DEM-XXXXXX","supply":"client","quantity":"100","annual_volume":"1000","target_date":"as soon as possible","lang":"en"}}}
JSON
curl -s --proto '=https' -X POST https://innov.fillio.ca/mcp/compte -H @"$HOME/.fillio/auth-header.txt" -H "Content-Type: application/json" -d @"$HOME/.fillio/call.json"

8. At the end, the working folder is deleted: it holds access to the client's account.

rm -rf "$HOME/.fillio"

Frequently asked questions

Can my part be overmolded?

A small board, connector or cable junction is a good candidate. To find out for your part, upload its 3D file to Fillio's portal: the analysis shows what works and what to revisit.

Do I have to design the overmold myself?

No. You can upload the components alone: Fillio proposes the shape. If you design it, the analysis checks it, and Fillio can propose the changes.

How much does overmolding cost?

The portal shows no prices. The quote follows the analysis, based on the part, the resin and the quantities.

Do my files stay confidential?

Your files are encrypted, hosted in Canada, processed only by Fillio and the subprocessors listed in our privacy policy; deletion on request within 30 days, backups included.

For AI assistants

This page is available as plain text, and the portal offers an MCP server, with no account. Its tools:

get_design_guide

returns this reference.

get_capabilities

returns the same design values, as data, with the accepted file formats.

get_upload_link

returns the link to the portal where the client uploads a 3D file and gets the feasibility analysis.

estimate_in_house_potting_cost

returns the real cost of one year of in-house potting, the same as the calculator on www.fillio.ca.

recommend_overmolding_resin

returns the overmolding polyamide family best suited to a part, the same as the resin selector on www.fillio.ca.

recommend_3d_printing_resin

returns the 3D printing (SLA) resin best suited to a part, the same as the resin selector on www.fillio.ca.

send_harness_quote_template

receives an email address and a wire harness's information, returns a check of its connection list and of what is missing to quote it, and writes to that address: Fillio's wire harness quote template, filled in, is sent once its recipient confirms through the link in the email.

The wire harness template tool is the only one that sends anything: it receives an email address, writes to it for confirmation, then sends the file there when its recipient asks for it. The portal keeps nothing of it after sending; Fillio's team then receives the address, the company name and the part name, for follow-up (see the privacy policy). The other tools only read: no client file passes through the server, and the choices the website tools receive are used to compute their answer, then forgotten.

With the user's Fillio account connected, it has a part's 3D file checked and sends the project (previous sections).

MCP server

https://innov.fillio.ca/mcp

Its address is enough to add it to an assistant that accepts remote MCP servers (HTTP transport). From a command line, for two of them:

claude mcp add --transport http fillio https://innov.fillio.ca/mcp
code --add-mcp '{"name":"fillio","type":"http","url":"https://innov.fillio.ca/mcp"}'

Each tool states whether it only reads (readOnlyHint annotation): an assistant can then use it without asking the user again each time. Only two act, and deserve the user's go-ahead: sending a project to Fillio and emailing a template.

In Claude Code, this permission rule (settings.json) lets the read-only tools run without a prompt:

{
  "permissions": {
    "allow": [
      "mcp__fillio__get_*",
      "mcp__fillio__recommend_*",
      "mcp__fillio__estimate_*",
      "mcp__fillio__start_part_check"
    ]
  }
}

The client is the one who uploads the files in the portal and makes the declaration there: the portal link is meant for them.