Custom Epicor Kinetic development for discrete manufacturers who have outgrown standard functionality — BPM directives, customization layers, BAQ-powered dashboards, REST API integrations, and Epicor Function Framework services — from a Zeeland, MI company with 20+ years building on Epicor for manufacturers between $10M and $500M in revenue.
Epicor Kinetic ships with hundreds of configurable modules covering MRP, scheduling, quality, financials, CRM, and shop floor control. For a generic discrete manufacturer with standard workflows, the out-of-box system handles the majority of day-to-day operations. But manufacturers do not compete on standard workflows. They compete on the 30% of their operations that are different from every other shop — proprietary quoting logic that factors in material certifications and customer-specific markup tiers, production routing rules that dynamically adjust based on machine availability and operator skill levels, quality inspection workflows triggered by customer requirements rather than a static inspection plan, and shipping compliance processes that vary by destination country, product classification, and end-customer regulatory framework. That 30% is exactly the functionality that Epicor's base configuration cannot address, and it is exactly where most Epicor implementations stall.
The typical Epicor customer hits the customization wall 6 to 18 months after go-live. The implementation partner configured the standard modules, migrated the data, trained the users, and left. Now the operations team is discovering all the edge cases that were not covered in discovery. The quoting department is maintaining parallel spreadsheets because Epicor's standard configurator does not support their pricing logic. The quality team is printing paper travelers because the standard inspection workflow does not match their actual process. Production schedulers are running a separate scheduling tool because Epicor's standard APS does not account for their setup time dependencies and tooling constraints. The warehouse team built a shadow system in Excel because the standard pick-pack-ship workflow does not handle their kit-to-order and partial shipment scenarios. Each of these workarounds represents a failure of the original implementation to address manufacturing-specific requirements — and each one introduces manual data entry, error risk, and process latency that the ERP was supposed to eliminate.
The cost of these workarounds is not theoretical. A manufacturer running parallel spreadsheets alongside their ERP is paying for the ERP license ($150 to $300+ per user per month on Kinetic SaaS, or $5,000+ per concurrent user for on-premise perpetual licenses) while still absorbing the labor cost and error rate of manual processes. We routinely see manufacturers spending $80,000 to $200,000 per year in labor on ERP workarounds — data re-entry, manual report compilation, spreadsheet-based scheduling, paper-based quality tracking — that exist solely because the Epicor implementation stopped at standard configuration. That is not a software problem. It is a customization gap, and closing it requires developers who understand both the Epicor platform internals and the manufacturing operations those customizations need to serve.
Quoting department maintains parallel spreadsheets because standard Epicor configurator cannot handle customer-specific pricing tiers, material certifications, or multi-level markup logic
Quality team prints paper travelers and inspection sheets because the standard inspection workflow does not match actual process requirements — traceability gaps on every job
Production schedulers run a separate tool because standard APS ignores setup time dependencies, tooling constraints, and operator qualification rules
Warehouse team built an Excel shadow system for kit-to-order, partial shipments, and customer-specific packaging requirements that standard pick-pack-ship cannot handle
$80K–$200K/year in labor burned on ERP workarounds — manual data entry, report compilation, and spreadsheet reconciliation that the ERP was supposed to eliminate
Original implementation partner configured standard modules and left — no one on staff knows how to build BPM directives, customization layers, or BAQ-based dashboards
Our engineers have built this exact solution for other businesses. Let's discuss your requirements.
FreedomDev builds custom Epicor Kinetic functionality for discrete manufacturers who need their ERP to match their actual operations — not the other way around. We work across every customization surface that the Epicor platform exposes: Business Process Management (BPM) directives for server-side logic, customization layers for UI modifications, Business Activity Queries (BAQs) for custom data retrieval and reporting, the Epicor Function Framework for reusable server-side services, REST API integrations for connecting Epicor to external systems, and custom dashboards that put operational data in front of the people who need it without requiring them to navigate five menu levels. Every customization we build is upgrade-safe, documented, and designed to survive Epicor version updates without requiring a full rebuild.
The Epicor customization landscape has changed significantly with the transition from Epicor 10 (WinForms-based, on-premise) to Epicor Kinetic (browser-based, cloud-capable). Manufacturers running Epicor 10 have accumulated years of C# customizations built in the Classic Customization Framework — form event handlers, custom assemblies, and BPM directives written against the Epicor 10 object model. Those customizations do not port directly to Kinetic. The Kinetic UI layer is browser-based, the customization framework is completely different (MetaFX/Application Studio instead of WinForms designers), and the recommended pattern for server-side logic has shifted from BPM-embedded C# to the Epicor Function Framework. FreedomDev handles both worlds: maintaining and extending Epicor 10 customizations for manufacturers who are not yet ready to migrate, and building native Kinetic customizations for those who have already moved or are mid-transition. We also handle the migration of Epicor 10 customizations to Kinetic — rebuilding them against the new framework rather than attempting brittle compatibility layers.
What separates FreedomDev from generic Epicor consulting shops is that we are a software development company that specializes in manufacturing. We do not just know how to write C# in a BPM directive or build a BAQ. We understand why a production scheduler needs to see setup time dependencies on the scheduling board, why the quality manager needs inspection triggers based on customer-part-operation combinations rather than a flat inspection plan, and why the shipping department needs automated BOL generation that pulls carrier-specific data from the sales order, the customer master, and the part master simultaneously. That domain knowledge is the difference between a customization that technically works and one that actually solves the operational problem it was built for.
BPM directives are the backbone of Epicor server-side customization. We build Method Directives that fire before or after any Epicor business object method — validating data on sales order entry, auto-populating fields on job creation, enforcing business rules on inventory transactions, triggering external API calls on shipment confirmation. Data Directives that fire when specific table records change — updating custom fields, cascading changes across related tables, writing to UD (User Defined) tables for custom tracking. Standard Directives for extending Epicor's built-in processing — adding custom logic to MRP generation, modifying how receipts post to GL, injecting validation rules into PO approval workflows. Every directive is built with proper error handling, transaction management, and logging so that failures surface immediately rather than silently corrupting data.
Epicor's UI customization framework lets you modify any standard screen without touching the base code. On Epicor 10, we build WinForms customization layers — adding fields, tabs, grids, and buttons to standard forms, wiring them to BPM-backed business logic, and binding them to UD table columns for custom data capture. On Kinetic, we use Application Studio to build browser-based UI customizations — custom panels, data views, event-driven logic, and responsive layouts that work on tablets for shop floor data entry. We also build entirely new screens for workflows that have no standard Epicor equivalent: custom quoting tools, production kitting interfaces, quality NCR (Non-Conformance Report) workflows, and customer-specific packaging compliance screens.
Business Activity Queries are Epicor's custom reporting and data retrieval engine. We build BAQs that range from simple filtered views (open orders by customer with ship-by date and margin) to complex multi-table queries with calculated fields, subqueries, and external BAQ references that power operational dashboards. Every BAQ we build is designed for performance — proper indexing hints, minimal cross-company joins, and pagination for large result sets. We then surface these BAQs as interactive dashboards with drill-down capability, tracker views for real-time monitoring, and updatable dashboards that let users edit data directly from the dashboard grid without navigating to the source entry screen.
The Epicor Function Framework is Epicor's modern approach to custom server-side logic — reusable C# functions that run as REST-callable services within the Epicor application server. We build EFF libraries for complex business logic that needs to be shared across multiple BPMs, called from external systems via REST, or scheduled via Epicor's built-in task scheduler. Common use cases: custom pricing engines that calculate quotes based on material cost APIs, customer tier rules, and volume breaks; automated job creation services that generate production jobs from sales order configurations; cross-company data synchronization services for multi-entity manufacturers; and custom document generation services that produce customer-specific packing lists, certificates of conformance, and shipping documentation.
Epicor Kinetic exposes a comprehensive REST API (v2) for every business object in the system. We build integrations that push and pull data between Epicor and your other platforms — CRM systems (Salesforce, HubSpot), e-commerce platforms (Shopify, BigCommerce, custom B2B portals), shipping carriers (UPS, FedEx, LTL providers), EDI translation services, quality management systems, and shop floor data collection devices. For Epicor 10 on-premise, we use the WCF/REST endpoints and SSRS for report-based integrations. Every integration includes authentication management (token refresh, API key rotation), rate limiting to avoid overloading the Epicor application server, retry logic with exponential backoff, and comprehensive logging for troubleshooting.
Epicor provides over 40 User Defined (UD) tables plus the ability to add UD columns to every standard table. We architect UD table structures that extend Epicor's data model for your custom requirements — additional part attributes, customer-specific compliance fields, production tracking data that does not fit standard Epicor fields, and equipment maintenance records. For manufacturers migrating from Epicor 10 to Kinetic, or from Epicor Vantage/Vista to Kinetic, we handle the full data migration including UD table data, BPM configurations, BAQ exports, and custom report definitions. We also build DMT (Data Migration Tool) templates and automated import routines for ongoing bulk data operations.
We had been running Epicor for three years with a quoting spreadsheet, paper quality travelers, and a scheduling whiteboard because our original implementation partner told us those workflows 'couldn't be done in Epicor.' FreedomDev built custom BPMs, a quoting dashboard, and an inspection workflow that eliminated all three within 8 weeks. Our quoting cycle dropped from 4 days to same-day, and we have not printed a paper traveler since.
We start by auditing your current Epicor environment — version, patch level, installed modules, existing customizations, BPM directives, BAQs, custom reports, UD table usage, and integration points. For Epicor 10 environments, we catalog every customization layer and BPM to assess upgrade-readiness for Kinetic. We then map your operational pain points against what Epicor can handle with configuration versus what requires custom development. Deliverable: a prioritized customization roadmap with effort estimates, dependency mapping, and a recommended implementation sequence that delivers the highest-impact customizations first.
Epicor customization requirements cannot be gathered in a conference room. We shadow the people who will actually use the customizations — production planners, quality inspectors, shipping coordinators, purchasing agents, shop floor operators — and document their actual workflows, not the workflows that management thinks they follow. For each customization, we define the trigger condition, the expected behavior, the data inputs and outputs, the error handling requirements, and the acceptance criteria. This step catches the 60-70% of edge cases that conference room requirements gathering misses.
All development happens in your Epicor pilot or test environment — never in production. We build BPM directives, customization layers, BAQs, Function Framework services, and integrations against your actual data (sanitized production copy) so that edge cases surface during development rather than after deployment. Each customization gets unit testing against normal cases, boundary cases, and failure cases. For BPMs, we test with deliberately bad data to verify that validation logic catches errors before they reach the database. For integrations, we load-test at 2 to 3 times expected transaction volume.
Your team tests every customization in the pilot environment using their actual daily workflows. We sit with them during testing, document every issue, and categorize findings as defects (not working as specified), enhancements (working as specified but the specification missed something), or training gaps (working correctly but the user does not understand the workflow). This phase typically generates 15 to 30 findings per customization project, and resolving them before production deployment eliminates the post-go-live firefighting that plagues most Epicor customization projects.
Production deployment follows Epicor's standard promotion process — customization layers, BPMs, BAQs, and Function Framework libraries are exported from pilot and imported to production during a scheduled maintenance window. We verify every customization in production with a checklist of test transactions, monitor for the first full business cycle (typically one week), and provide 30 days of hypercare support for issues that surface in production use. Ongoing support covers Epicor version updates (verifying customization compatibility after patches and upgrades), new customization requests, and performance tuning as transaction volume grows.
| Metric | With FreedomDev | Without |
|---|---|---|
| Epicor Platform Expertise | BPMs, customization layers, BAQs, EFF, REST API — deep platform knowledge | Generic ERP consultancies: surface-level Epicor configuration |
| Manufacturing Domain Knowledge | 20+ years building for discrete manufacturers — understand shop floor operations | IT generalists: know the software, not the manufacturing workflows it needs to serve |
| Upgrade-Safe Customizations | Customization layers, supported APIs, Function Framework — survives version updates | Direct code modifications, unsupported hacks — breaks on every Epicor patch |
| Kinetic + Epicor 10 Coverage | Build and maintain on both platforms, plus Epicor 10 to Kinetic migration | Most shops specialize in one or the other — no migration path |
| Custom Integration Development | Full REST API integration to any external system — CRM, e-commerce, EDI, shop floor | Limited to pre-built connectors or CSV/flat file imports |
| Post-Deployment Support | $1,500–$4,000/mo — ongoing customization support, patch compatibility, performance tuning | $200–$400/hr time-and-materials with no proactive monitoring |
| Requirements Depth | Shop floor shadowing, operator interviews, edge case documentation before writing code | Conference room requirements gathering from management — misses 60-70% of edge cases |
| Development Methodology | Pilot environment, UAT with actual operators, production promotion checklist | Develop and deploy directly to production — hope it works |
Schedule a direct technical consultation with our senior architects.
Make your software work for you. Let's build a sensible solution.