Custom software. From the inside out.

We meet the people doing the work, ask questions, and take notes. We map the current process, agree what matters, and turn assumptions into decisions before choosing a solution.

We build focused tools around the requirements. For this website, “read clearly” includes a sensible heading structure. This small Python parser checks the markup; the button below checks the current page in your browser.

from html.parser import HTMLParser
from pathlib import Path

class HeadingAudit(HTMLParser):
    def __init__(self):
        super().__init__()
        self.headings = []

    def handle_starttag(self, tag, attrs):
        if tag in ("h1", "h2", "h3"):
            self.headings.append(tag)

page = HeadingAudit()
page.feed(Path("index.html").read_text())
assert page.headings.count("h1") == 1
assert page.headings[0] == "h1"

Python’s HTMLParser ↗ reads the markup without another dependency. These checks confirm one main heading, placed before subheadings; they are a starting point for a wider accessibility review.

A project brief can become a business workflow. Before storing a request or scheduling work, check its input. A launch date before the start date is a useful error to catch at the boundary.

from django import forms

class ProjectBrief(forms.Form):
    email = forms.EmailField()
    start = forms.DateField()
    launch = forms.DateField()

    def clean(self):
        data = super().clean()
        start = data.get("start")
        launch = data.get("launch")

        if start and launch and launch < start:
            self.add_error(
                "launch", "Launch cannot precede the start."
            )
        return data

Django forms ↗ handle field validation and attach errors to the right input. Views handle the request; shared services handle the workflow. This example belongs in a Django application, not this static page.

Put that validated brief in front of a person. Start with a regular form, then enhance the interaction: replace just the form with its result, keeping validation on the server.

<form id="brief-form"
      method="post"
      action="/briefs/"
      hx-post="/briefs/"
      hx-target="#brief-form"
      hx-swap="outerHTML">
    {% csrf_token %}
    {{ form.as_div }}
    <button type="submit">
        Let's build something
    </button>
</form>

HTMX ↗ adds targeted requests and HTML updates. This application excerpt needs a Django endpoint and HTMX loaded in its parent page. Our homepage keeps its interactions in native JavaScript.

The order view from our workshop needs a consistent language. Translate each source’s fields into a shared model, reject unknown states, and record enough context to follow the result.

import logging

logger = logging.getLogger("integrations.orders")

def normalize_order(payload):
    states = {"shipped": "Dispatched", "held": "Needs review"}
    status = states.get(payload["state"])
    if status is None:
        raise ValueError("Unsupported order state")

    order = {
        "external_id": str(payload["id"]),
        "status": status,
    }
    logger.info("Order normalized", extra=order)
    return order

A mapping function is one part of an integration. The surrounding service records success and failure, applies retry rules, and exposes a searchable history. Logs retain useful context while sensitive payload fields are redacted. See how the systems connect ↓

A good release is repeatable. Describe the desired files and permissions, then let the tooling bring the server into that state. This standalone publishing recipe uses an example web root.

- name: Publish a static page
  hosts: web
  become: true
  tasks:
    - name: Create the web root
      ansible.builtin.file:
        path: /var/www/example
        state: directory
        mode: "0755"

    - name: Put HTML in place
      ansible.builtin.copy:
        src: index.html
        dest: /var/www/example/index.html
        owner: root
        group: root
        mode: "0644"

Ansible’s copy module ↗ manages the file and its permissions. Nginx serves it. The full deployment also configures HTTPS, checks Nginx before reloading, and schedules certificate renewal.

We build our own AI chat into the platform, connected to MCP servers that expose useful business tools. An agent can retrieve an order, explain an integration failure, or prepare an action using the current user’s permissions.

1. 01

   We build your chat interface.

   A custom experience inside your product, with streaming replies, conversation history, and visible activity.

2. 02

   We connect agents to MCP tools.

   Servers and tools that connect the agent to your application services, business data, and integrations.

3. 03

   We build permissions and activity logs.

   User-aware access, confirmations for sensitive actions, and a readable history of requests, results, and changes.

{
  "jsonrpc": "2.0",
  "id": "demo-request-001",
  "method": "tools/call",
  "params": {
    "name": "get_order_status",
    "arguments": {
      "order_id": "DEMO-101"
    }
  }
}

Our chat handles the conversation and presents results. MCP tools ↗ connect the agent to application services and integrations. The platform enforces permissions, records tool activity, and asks for confirmation where a workflow needs it.