Products and Services

Standard ERP systems like SAP, Odoo, and Microsoft Dynamics are built in layers: a generic technical core surrounded by shells of configuration, and further out, your own company-specific rules. The mistake most integrations make is reaching into that core to force the software to match your workshop — which works fine until the vendor's next upgrade breaks it. We build the custom part as a separate layer on top, not inside.

• Extension over modification: your workshop-specific logic is built as an add-on layer on top of the standard ERP, never by rewriting the ERP's own source code — so vendor upgrades don't silently break your setup.
• Customizing first: wherever the standard system already supports what you need through vendor-approved configuration, we use that — it's cheaper, faster, and stays upgrade-compatible.
• Core-shell mapping: before building anything, we identify which of your requirements sit close to the generic core (already handled by standard functions) and which sit further out, in your company-specific rules, where custom development is actually needed.
• No source-code changes: we don't touch the ERP's own core code — that path is the fastest way to end up with a system that fails the moment the vendor releases an update.
• Right-sized build: standard software already covers the parts of your process that are common to any workshop; we build custom only for the parts that are genuinely specific to how you operate, so you're not paying to reinvent what already works.

The result is software that matches how your workshop actually runs today, and keeps working after your ERP vendor's next release.

A database is only as good as its architecture — the split between how data is stored and how it's used is what determines whether a system stays fast as your business grows, or slows to a crawl and needs a costly rebuild.

• Layered design: we separate the external layer (what each application or form actually shows a user), the conceptual layer (the full logical data model, independent of any one screen), and the internal layer (how data is physically stored — files, indexes, block layout) — so each layer can change without breaking the others.
• Data independence: add a new field or restructure a table without breaking every application built on top of it; add an index or reorganize physical storage without touching the logic or apps above it.
• Storage-aware design: RAM is fast but volatile, disk/SSD is slower but persistent — we design around where the real bottlenecks sit instead of just throwing more hardware at the problem.
• Concurrency planning: seek time, rotational latency, and transfer time add up on disk, which is why a system slows down when many people enter data at once — shift change being the classic case. We plan for those load moments up front, not after they start generating complaints.
• Growth-ready structure: because the layers stay properly separated, new fields, new reports, and rising data volume get absorbed as your operation grows, instead of forcing a full rebuild.

The result: a database that stays fast and reliable as your workshop or trading operation scales, rather than one you have to tear down and rebuild every time you add a product line or a new report.

Most manufacturers and trading businesses run day-to-day on an operational system — order entry, stock movements, invoicing — built to process many small transactions fast. The moment you point heavy analytical queries at that same system, it slows down and can lock up. We build a separate analytical layer designed for exactly the questions your operational system can't answer quickly.

• Data warehouse setup — a dedicated store that pulls data out of your operational (OLTP) systems and scattered spreadsheets, so analytical queries never touch, or slow down, the systems your team uses to take orders and manage stock.
• Star schema modeling — we organize your data around one central fact table (the numbers you actually want to measure — sales amount, delivery time) surrounded by dimension tables (time, customer, product, warehouse), so a new question doesn't require a new custom query or a new IT project every time.
• Self-serve exploration — once your data is modeled this way, you can slice it (fix one dimension, e.g. this quarter only), dice it (filter several dimensions at once), drill down from summary to detail, or roll up detail into a summary — without waiting on us or your IT team.
• Dashboards and forecasts — built on top of that same structure, so the numbers on screen always trace back to one consistent model, not a one-off spreadsheet pull.

The result: reporting slowness and "we can't answer that without a project" stop being permanent facts of life — they were always a sign the analytical layer hadn't been built yet, not a sign you needed more computing power.

Before we automate anything, we map how the process actually runs today — not how the org chart says it should run. That step catches costly logic errors while they're still cheap to fix: on paper, not in production code.

• Process mapping first: we document the current process step by step as an event-driven process chain, marking explicitly where only one path can be taken (exclusive-or) and where several steps genuinely run at the same time (parallel/AND) — ambiguity here is where most automation projects go wrong.
• Parallel logic, not just sequential logic: on a delivery-time calculation module we built on an ERP system, an order split across multiple warehouses uses an AND-gateway — each warehouse's pick-and-ship time runs in parallel, and the total delivery time is the maximum of those times, not their sum. A naive sequential build would have systematically quoted every split order too slow.
• One hub, not spaghetti: instead of wiring every system directly to every other system — a setup that becomes unmanageable the moment you add a third or fourth tool — we connect your order intake, invoicing, and reporting tools to one central system of record, so adding a new tool later means one new connection, not a rebuild.
• Automation on top of a mapped process: only once the logic is verified on paper do we build the actual automation — order intake forms, invoice generation, reporting dashboards, data flows between systems.

Skip the mapping step and automation just makes your existing mess run faster; map it first and you get a process that's actually correct, plus a system that's still workable when you add the next tool.

Being profitable on paper and being able to pay your bills are two different problems. Manufacturing sits on the investment side of the business: you pay for materials and labor today, and the customer pays you back months later. That timing gap — not a lack of profit — is what causes companies with a full order book to suddenly run out of cash.

• Cost accounting and financial statements — the baseline numbers: what each order actually costs you, and whether the business as a whole is profitable.
• Liquidity gap analysis — mapping when money actually leaves and returns to the business, separate from when profit gets booked.
• Working-capital tools — customer deposits (financing at zero cost), payment milestones matched to your customer's own payment schedule, selling receivables (factoring/forfaiting) to get paid early, and letters of credit that let you borrow against a guaranteed payment.
• Early-payment discount review — the gap between a supplier's cash price and credit price is often a hidden interest rate of 60-70% a year, making late payment one of the most expensive financing decisions a business can make without noticing.
• Investment appraisal — deciding which equipment, expansion, or contract is actually worth the capital it ties up.

The result: you stop managing the business by profit alone and start managing the timing of cash — usually the real difference between a company that scales and one that quietly runs out of money with a full order book.

Most security problems in manufacturing and trading businesses aren't exotic — they're exposed admin panels, default passwords still active on production equipment, and systems nobody has patched in years. We start with a review of what you actually have running today, then close the gaps that matter most, and build any new software so security is part of the design rather than an afterthought.

• Security review: we examine your existing systems — servers, databases, network access, admin interfaces — to find what's actually reachable from outside, rather than running a generic checklist and selling you a report.
• System hardening: we reduce the attack surface on the infrastructure you already have — closing unused ports and services, tightening firewall rules, restricting who and what can reach your servers and databases.
• Secure-by-design development: when we build new software for you, access control and data protection are part of the architecture from day one, not bolted on after launch.
• Production and ERP-specific risks: manufacturers often run ERP systems, IoT sensors, and production equipment with weak or default credentials and unpatched software — we check these specifically, not just the office network.
• Practical fixes over theory: trained in internet security and ethical hacking, we focus on the vulnerabilities that could actually be exploited in your setup and hand you concrete steps to close them.

The result: fewer easy entry points for attackers, and systems and data that stay under your control as your business grows.

Most B2B websites for manufacturers and trading businesses are generic templates with stock photos and vague claims — they don't explain what the company actually does or why a buyer should trust it. We build and run the alternative: a web presence that does real selling work, built around a positioning decision about who you actually want to reach and how you want to be seen.

• Digital presence recovery: for local and small businesses that have lost control of a Google Business Profile, website, or social accounts, we help reclaim access and make sure the business itself is the account owner going forward.
• Local SEO and listings: getting a business found in local search, and cleaned up across third-party directories that keep pointing customers to an outdated or wrong listing.
• Website: a site built around your actual capability — machines, processes, certifications, product range — not a generic template with your logo swapped in.
• Content: articles, guides and case material that demonstrate real expertise to a buyer doing due diligence, instead of generic sales copy that could belong to any competitor.
• Positioning: a deliberate decision on how your company should be perceived by the customers you actually want — not whoever happens to land on the page.
• Marketing automation: forms, follow-up sequences and lead capture that turn a visitor into a qualified conversation, without someone manually chasing every enquiry.
• Sustainable positioning: where relevant, framing your sourcing, materials or process for buyers who are actively screening suppliers on sustainability grounds.

This isn't theoretical: archilion.com itself — the site you're reading right now — is built exactly this way, a working example of what the approach produces.

Production planning only works when three layers line up: what you make, how you make it, and in what sequence — and none of that holds if the current state of your shop floor is invisible to whoever is doing the planning. Strategy work here starts by making that state visible, then decides what to build and in what order based on where the real bottleneck sits, not on what sounds most ambitious.

• Shop-floor visibility: before any planning decision is worth making, we get the current state of production — what's actually happening on the floor — visible to the people who plan it.
• Three-layer planning: we work through what to make, how to make it, and in what sequence as three connected decisions, not three separate projects.
• The fourth factor: labour, equipment, and materials rarely limit growth on their own — a workshop usually grows when the planning and organization layer sitting on top of them gets stronger, not when another machine gets added.
• Cash-first sequencing: the two bottlenecks that touch cash directly — order intake and invoicing — are usually the right place to start; fixing them typically pays for itself within months and buys the room to fix everything else.
• Ambition last, cash first: we deliberately avoid starting with the most impressive-sounding project — that's usually the wrong order of operations.

The result is a build order you can defend with cash flow, not a wish list of projects ranked by how good they sound.

Choosing a system or setting a digitalization roadmap is usually a decision you only get to make once — the wrong vendor or the wrong sequencing can cost months and real money. This advisory exists to give you an outside, technically grounded opinion before you commit.

• Independent — recommendations are not tied to selling you one specific ERP, software product, or platform; the advice is about what actually fits your operation, not what earns a referral commission.
• Hands-on evaluation — vendor claims and technical trade-offs are assessed by someone who has actually built and implemented systems, not just presented strategy slides, so the gap between a sales pitch and what a system can really deliver gets caught early.
• Language and cultural bridge — working fluently in Vietnamese, English, and German, this advisory sits directly between international manufacturing reality and German technology and manufacturing practice, so nothing gets lost in translation on either side.
• Priorities before purchases — before any system gets selected, we work out what to fix first, what to defer, and what to skip entirely, so your budget goes toward the changes that actually matter.

The result is a second opinion you can trust before signing a contract or starting an implementation — not another vendor pitch.