My Posts

The Challenge: Prose and Manual Processes

Business rules are the invisible framework of your company. They determine how decisions are made, what criteria must be met, and how workflows are structured. However, today these rules are often documented in policies, guidelines, and best practices in pure “prose.”

The problem?

– When handling customer inquiries, orders, or complaints, employees must sift through documentation to find the relevant rules.

– This is not only time-consuming but also prone to errors.

Perhaps you have already considered using generative AI (GenAI) for decision-making. However, in practice, this often reaches its limits:

– The rules are vaguely formulated, sometimes contradictory.

– The AI’s decisions are not always transparent.

– Can you really trust it?

My Proposal: LLM + BRMS – A Rarely Implemented Combination

Business Rules Management Systems (BRMS) offer a proven solution:

– Rules are stored in a machine-readable format and automatically validated.

– The challenge has been the labor-intensive manual transfer of rules into a BRMS.

– The good news? Large Language Models (LLMs) can drastically simplify this process.

Two-Stage Process for AI-Supported Business Rule Processing

1. Preprocessing (Rule Extraction & Standardization)

– Your documents—contracts, policies, and best practices—are analyzed by an LLM.

– The AI extracts relevant rules and converts them into a standardized, machine-readable format.

– A manual review by an AI administrator ensures that the rules are correct and free of contradictions.

2. Processing (Automated Decision-Making)

– Customer inquiries (claims, orders, requests) are processed by a traditional AI.

– The AI extracts relevant data and forwards it to your workflow system.

– Decisions are based on the rules stored in the BRMS, which have been reviewed by human experts.

Why This Approach Works

1. The Best of Both Worlds: LLM + Traditional AI

– LLMs handle the tedious task of extracting rules from documents.

– Traditional AI processes inquiries and structures input data.

2. Human Oversight for Security and Precision

– Rules are not blindly adopted but validated by experts.

– Errors and unclear formulations can be identified and corrected early.

3. Transparency and Traceability

– No black-box decisions: all rules are explicitly stored and traceable.

– No risk of “hallucinations” or bias from a generative AI.

– You always have control and can review and adjust decisions.

Why You Should Consider This Now

The combination of LLMs and BRMS is a promising approach to making business rule management more efficient and transparent. You can:

– Save time.

– Reduce errors.

– Establish an AI-supported yet human-controlled decision management system.

Since this approach has been rarely implemented so far, it is worth exploring its potential for your company in more detail.

Sources:

[1]: Original diagram for AI-supported business rule processing, created by the author.

Imagine you have a reliable compass that guides you from the roots of Lean in manufacturing all the way to modern approaches in IT and services. That’s exactly what we’ll explore here: how Lean began at Toyota, how it evolved into Agile and DevOps – and what practical steps you can take yourself.

The Starting Point Lean in Manufacturing

Your compass’s “North” lies in Japan in the 1950s, when Toyota began developing a new production system. This Toyota Production System (TPS) was built on:

– Elimination of waste (Muda)

– Continuous improvement (Kaizen)

– Pull systems (e.g., Kanban)

– Respect for people and involving employees

Although Taiichi Ohno, Shigeo Shingo, and other Toyota pioneers initially passed on their knowledge mostly internally, influential books like Toyota Production System*by Taiichi Ohno[1] and A Study of the Toyota Production System by Shigeo Shingo[2] later brought TPS worldwide attention.

In the 1980s and 1990s, Lean was popularized by works such as Masaaki Imai’s Kaizen[3] as well as The Machine That Changed the World[4] and Lean Thinking[5] by James P. Womack and Daniel T. Jones. Western industry soon realized that Lean could make processes more efficient, improve quality, and better involve people in improvement initiatives.

Changing Course From the Shop Floor to IT

Your compass now points to a new direction – IT and product development. The article “The New New Product Development Game” (1986) by Hirotaka Takeuchi and Ikujiro Nonaka[6] highlighted that cross-functional, self-organized teams and rapid iterations can spark true innovation. Ken Schwaber and Jeff Sutherland later built on these ideas to develop Scrum.

2001 marked a milestone: the Agile Manifesto[7] with its four values and twelve principles directly linked to Lean concepts. Rapid feedback loops, a constant focus on delivering maximum value to the customer, and an emphasis on essentials closely resembled Lean’s core ideas. Scrum – first described in detail in Agile Software Development with Scrum by Ken Schwaber and Mike Beedle[8] – put these ideas into practice.

Mary and Tom Poppendieck underscored this connection in 2003 with Lean Software Development An Agile Toolkit [9], showing that agility is essentially Lean repackaged for a new environment fast, streamlined, value-oriented, waste-free, and continuously improving.

DevOps From Individual Teams to the Entire Value Stream

Now your compass zooms out from software development to the entire process. Books like Continuous Delivery [10] and The DevOps Handbook [14] made it clear that efficiency and fast value delivery don’t end with development. By consistently automating and tightly integrating development and operations (Dev and Ops), you can eliminate long wait times, coordination problems, and seemingly endless release cycles.

DevOps demonstrates how a continuous flow – from idea to delivery – is possible, aligning with Lean principles but tailored to the IT world. The Phoenix Project [13] introduced these ideas to a wider audience by using a novel-like format, showing how companies can optimize their IT processes with Lean and DevOps practices. Accelerate [15] offered scientific evidence that these approaches really do lead to faster deployment cycles, greater stability, and better business outcomes.

Sources:

[1]: Ohno, T. (1978/1988) Toyota Production System Beyond Large Scale Production. Productivity Press

[2]: Shingo, S. (1981) A Study of the Toyota Production System From an Industrial Engineering Viewpoint. CRC Press

[3]: Imai, M. (1986) Kaizen The Key to Japan’s Competitive Success. McGraw Hill

[4]: Womack, J. P. Jones, D. T. Roos, D. (1990) The Machine That Changed the World. Free Press

[5]: Womack, J. P. Jones, D. T. (1996) Lean Thinking. Simon & Schuster

[6]: Takeuchi, H. Nonaka, I. (1986) The New New Product Development Game. Harvard Business Review Jan–Feb 1986

[7]: Agile Alliance (2001) Manifesto for Agile Software Development [the agile manifesto](https://agilemanifesto.org)

[8]: Schwaber, K. Beedle, M. (2002) Agile Software Development with Scrum. Prentice Hall

[9]: Poppendieck, M. Poppendieck, T. (2003) Lean Software Development An Agile Toolkit. Addison-Wesley

[10]: Humble, J. Farley, D. (2010) Continuous Delivery. Addison-Wesley

[11]: Anderson, D. J. (2010) Kanban Successful Evolutionary Change for Your Technology Business. Blue Hole Press

[12]: Ries, E. (2011) The Lean Startup. Crown Business

[13]: Kim, G. Behr, K. Spafford, G. (2013) The Phoenix Project. IT Revolution Press

[14]: Kim, G. Humble, J. Debois, P. Willis, J. (2016) The DevOps Handbook. IT Revolution Press

[15]: Forsgren, N. Humble, J. Kim, G. (2018) Accelerate The Science of Lean Software and DevOps. IT Revolution Press

Navigating Specialized Language Like an Experienced Sailor

Learning foreign languages is like sailing on open waters: without the right equipment and technique, you quickly find yourself stuck. One of the biggest challenges is mastering specialized vocabulary, which is often missing from conventional textbooks. In this post, I demonstrate how to systematically acquire specialized terminology—using Dutch sailing terminology as an example, but with a method that can be applied to any language or field.

Learning Goal: Automation Through Auditory Learning

The aim of this approach is to build specialized vocabulary in a way that seamlessly integrates into daily life. By utilizing a text-to-speech system, about 90 minutes of audio material could easily be generated —perfect for listening during car rides or other routine activities. This way, terminology is absorbed naturally and effortlessly.

Hear the result (it is in German as this is my mother tongue and my target language is Dutch, but the process can easily be transferred to any combination of languages).

The Path to a Specialized Vocabulary

Researching a Reliable Source

A strong foundation starts with a high-quality source. In this case, the choice was a PDF from a Dutch sailing school, specifically designed for sailing instructors. It provides correct terminology in a well-structured format.

Extracting the Data

Once the source was secured, the text was extracted as a markup document. Here, ChatGPT was used to identify specialized terms and place them into short, practical sentences for contextual understanding.

Unlocking Content: Converting PDFs to Markdown with marker-pdf

Translation and Preparation

Learning individual words is not very effective—embedding them into natural contexts makes all the difference. Therefore, the Dutch terms were integrated into coherent example sentences and paired with corresponding German translations. The result: sentence pairs that convey both meaning and correct usage.

Technical Implementation

To make the content available for auditory learning, a JSON file containing the sentence pairs was created. This file serves as the foundation for a text-to-speech system that delivers Dutch terminology in natural speech. This turns vocabulary learning into an engaging auditory experience, which can be used, for example, during car rides to reinforce specialized vocabulary.

Your Personal Language Lab on the Go: Learning Languages While Driving

Conclusion: Efficient Language Learning Through Targeted Methods

This approach demonstrates that acquiring specialized vocabulary does not have to be a dry task. With the right combination of source research, data preparation, and technical implementation, an effective and everyday-friendly learning process can be designed. And who knows—mastering sailing terminology might just be the beginning of an exciting journey into other specialized language fields.

Have you ever tried to efficiently extract information from a PDF? Whether you need the content for documentation, a blog project, or better organization, converting PDFs to Markdown provides a clear and flexible way to access and work with that information. With marker [1], you have a powerful tool at your fingertips to do just that.

In this post, I’ll show you how to set up and use marker-pdf to transform PDFs into Markdown files. Markdown is a versatile, text-based format that’s perfect for structured content. This approach will help you quickly unlock important information and make it actionable for your projects.

Why Convert PDFs to Markdown?

PDFs are a widely used format, but they’re not always easy to edit or repurpose. Markdown, on the other hand, is simple, lightweight, and incredibly flexible. By converting PDFs to Markdown, you can better organize, analyze, and integrate the content into your workflow.

Setting Up marker-pdf: Step-by-Step Guide

Getting started with marker-pdf is straightforward. Follow these steps to have the tool up and running in no time:

1. Create a Working Directory

First, create a clean directory to work from:

mkdir marker_pdf

cd marker_pdf

2. Set Up a Virtual Environment

To use marker-pdf, it’s a good idea to create a virtual Python environment. This isolates your project dependencies:

uv venv --python 3.11

3. Install Required Dependencies

Now, install the necessary packages to run marker-pdf:

uv pip install torch torchvision

uv pip install streamlit

uv pip install marker-pdf==1.2.3

⚠️ Note: Avoid version `1.2.4` as it contains known issues. Version `1.2.3` is stable and recommended.

4. Converting PDFs: How It Works

marker-pdf gives you two flexible options for converting PDFs to Markdown – using a graphical user interface (GUI) or directly via the command line.

Option 1: Using the GUI

For a visual and user-friendly approach, launch the GUI with this command:

uv run marker_gui

In the interface, you can simply select your PDF and start the processing. The result will be automatically generated.

Option 2: Processing Directly via Command Line

If you prefer working in the command line, you can process a PDF directly. First, create an output directory:

mkdir output

Then process the PDF with the following command:

uv run marker_single path/to/example.pdf output

The contents of the PDF will be converted into Markdown files and saved in the `output` directory.

Results: What You Get

After processing with marker-pdf, you’ll find the following in your output directory:

– Markdown Files: These contain the structured content from the PDF, ready for further use.

– Extracted Images: Any images included in the PDF are saved separately for easy access.

These files are a great starting point to unlock content and make it actionable.

A Tool for Clear Content

marker-pdf is a valuable tool for making content from PDFs accessible and editable. Converting to Markdown helps you structure information and integrate it into your workflow. Whether for documentation, analysis, or creative projects, this tool simplifies working with PDF content.

Now it’s your turn: try out marker-pdf and see how easy it is to unlock content from PDFs and transform it into a usable format. It’s a step toward more clarity and structure in your work.

Sources:

[1]: The Github Repo for Marker

In personal knowledge management, a Zettelkasten can serve as a lifelong companion for capturing, organizing, and interlinking ideas. However, while the benefits of the Zettelkasten method are widely discussed, less attention is given to the underlying system’s longevity. A robust setup ensures that your notes remain accessible and usable regardless of how software and tools evolve.

In this post, I’ll walk you through my setup, which prioritizes durability, portability, and adaptability, and explain the practical benefits from a user perspective.

Why Focus on System Longevity?

Software changes fast. Tools like Notion, Obsidian, or Roam Research can offer incredible features today but may change their business models, lose support, or even disappear. To prevent losing years of valuable notes, it’s essential to design a system independent of any single tool.

The key? Use open formats, decentralized storage, and workflows that can adapt to new tools as they emerge.

My Evergreen Zettelkasten Setup

1. Markdown for Portability

All my notes are stored as plain-text Markdown files. This approach offers several advantages:

– Open standard: Markdown is widely supported by many tools and platforms.

– Human-readable: Even without specialized software, the files can be easily read and edited.

– Tool-agnostic: Since almost every note-taking app supports Markdown, switching tools becomes simple.

2. Structured File Naming for Easy Navigation

To keep my notes organized, I use a structured file naming convention inspired by Niklas Luhmann’s Zettelkasten system. Each note receives a unique identifier, such as 123_17_knowledge_management_03d7dc503.md. This method ensures clear navigation and avoids issues with duplicate names.

I developed a Python script to automate this process:

– It generates unique IDs for new notes.

– It updates internal links whenever notes are renamed or moved.

This automation helps maintain consistency as the Zettelkasten grows.

3. Git for Version Control and Backup

To ensure my notes are always backed up and versioned, I store them in a Git repository. The benefits include:

– Version history: I can track every change and revert to previous versions if necessary.

– Reliable backup: The distributed nature of Git means my notes are stored across multiple devices.

– Cross-device sync: I can seamlessly sync my Zettelkasten between desktop, laptop, and mobile devices.

On mobile (iOS), I use Working Copy to pull my Git repository and edit notes in Obsidian. This workflow keeps my notes accessible wherever I am.

4. Flexible Editing with Multiple Tools

For editing, I rely on two main tools:

– Obsidian: A versatile Markdown editor with excellent linking and graph visualization features.

– VS Code: Ideal for bulk editing and working with large text files.

This flexibility ensures that I’m never locked into a single tool. If a new, better tool emerges, I can adopt it without disrupting my workflow.

5. Managing Media Files for Long-Term Access

Since I frequently use diagrams and images in my notes, I’ve established a straightforward approach to media management:

– I create visuals using apps like Concepts.

– Final images are saved in universal formats like JPEG or PNG.

– Media files are stored alongside the relevant notes, ensuring they remain accessible even if I switch tools.

Key Benefits of This Setup

1. Data durability: By using open formats and decentralized storage, my notes remain future-proof.

2. Portability: Switching tools is easy because my data isn’t locked into any proprietary platform.

3. Consistency: Automated naming and linking ensure that my Zettelkasten stays well-organized, even as it grows.

4. Flexibility: I can integrate new tools or workflows without losing access to my existing notes.

Practical Tips for Your Own Zettelkasten

– Start simple: Use plain text or Markdown for your notes.

– Automate where possible: Scripts can save time and reduce errors in large systems.

– Back up regularly: Use a version control system like Git to keep your notes safe.

– Stay adaptable: Design your system so that you can easily adopt new tools as needed.

Final Thoughts: Building for the Long Haul

A well-designed Zettelkasten system isn’t just about capturing knowledge—it’s about ensuring that your knowledge remains accessible and usable for years to come. By focusing on open formats, flexible tools, and reliable backups, you can build a system that grows with you and adapts to whatever the future holds.

I hope this post has provided some useful insights into creating a durable Zettelkasten setup. If you have your own strategies or questions, feel free to share them—I’m always interested in learning how others approach this challenge!

Imagine turning your long drives into a personal language lab. No more wasted time—just an opportunity to improve your language skills effectively, without needing a screen or taking your hands off the wheel. Sounds fascinating, doesn’t it?

If you’ve ever tried to learn a foreign language, you’ve likely noticed how hard it can be to find methods that seamlessly fit into your daily routine. That’s where my approach comes in: interactive language exercises in MP3 format that make learning possible and flexible during long drives.

How Does It Work?

Creating the Content:

The first step is creating the exercises. This is where ChatGPT comes into play. I use this AI tool to generate specific language exercises tailored precisely to my current learning goals. The exercises are structured in JSON files and include:

Lessons: Thematically organized content (e.g., grammar or conversation).

Tasks: Sentences or questions that you need to answer in the target language.

Solutions: The correct answer for comparison.

Example of a JSON task:

"teacher_speaks": {
    "text": "Hij zegt: 'Ik ga morgen naar Amsterdam.'",
    "language_code": "nl"
  },
  "student_response_time": 5000,
  "teacher_solution": {
    "text": "Hij zegt dat hij morgen naar Amsterdam gaat.",
    "language_code": "nl"
  }
}

Automatic Voice Conversion:

To create audio exercises from these texts, I developed a Python script. This script processes the JSON files and uses the text-to-speech technology from ElevenLabs to convert them into MP3 files. The voices are clear and natural—perfect for language learning.

German voices explain the tasks and provide instructions.

Voices in the target language present the tasks and solutions.

Structure of the Audio Exercises:

The finished MP3 files are logically structured:

Introduction: A brief explanation of the task.

Task: The sentence or question is read aloud.

Pause: A 5-second pause to formulate your answer.

Solution: The correct answer is read aloud.

The pauses are deliberately designed to give you enough time to respond spontaneously without interrupting the flow of the lesson.

On-the-Go Application:

Once the MP3 files are created, I upload them to my smartphone. During drives or commutes, I listen to the lessons, formulate my answers mentally or aloud, and directly compare them with the provided solution. This way, I effectively train listening comprehension and language production—without having to set aside extra time.

Why This Method Works So Well

Hands-Free, Screen-Free: Perfect for driving and commuting.

Flexibility: The content can be tailored to your current learning needs.

Realistic Listening Practice: Thanks to the natural voices from ElevenLabs.

Easy to Implement: MP3 files work on any device.

Make Your Drives Productive

With this method, you can turn your driving time into an opportunity to build new language skills—without added stress or effort. Give it a try and make every drive a lesson! Which language would you like to learn this way? Let me know in the comments and share your experiences!