# Hikmah Technologies

> Production AI on your own data — lean data platforms and approval-gated AI workflows, internals public

Arshad Ansari is a solo data and AI engineer based in Navi Mumbai, India, working with
B2B SaaS and product companies worldwide (30–200 people, zero to three data people, no
senior platform owner). The practice sells one thing: production AI on your own data —
the data-engineering rigour that makes an AI workflow trustworthy, built by the person
who will also operate it. Engagements run $3,000 for a fixed-price audit to $15–40k for a
full build, against the $150–200k senior hire that is the usual alternative.

What makes the claims checkable: the internals are public. 3 live systems are documented
with real numbers rather than case-study prose — 4,912 pipeline partitions at
99.9% success, and 51 AEGIS workflow types running over
79 permission-gated tools, where every risky action stops for approval before it runs.

## Start here

- [Home](https://hikmahtechnologies.com/): The position, the proof numbers, and who should not hire me
- [Data Engineering Consultant](https://hikmahtechnologies.com/fractional-data-engineer/): The data half: what an independent, fractional data engineering consultant does, costs, and when to hire full-time instead
- [AI Automation Consultant](https://hikmahtechnologies.com/ai-automation-engineer/): The AI half: shipping LLM workflows that survive production, and the alternatives to hiring me
- [DuckDB consulting](https://hikmahtechnologies.com/duckdb-consulting/): A fixed-price, one-week assessment of whether a workload fits DuckDB, with the full production-fit checklist published on the page
- [How I work](https://hikmahtechnologies.com/how-i-work/): Scoping, pricing, communication and what I expect from a client
- [FAQ](https://hikmahtechnologies.com/faq/): Direct answers on rates, contracts, timelines and working across time zones

## Free and ungated — no email required to read

- [Data Platform Teardown](https://hikmahtechnologies.com/data-platform-teardown/): The 18 checks from the $3,000 audit, published in full
- [AI Workflow Teardown](https://hikmahtechnologies.com/ai-workflow-teardown/): 17 questions to ask before an LLM workflow is trusted in production: control, reliability, cost, trust
- [Warehouse cost calculator](https://hikmahtechnologies.com/snowflake-cost-calculator/): Estimate your warehouse spend against a lean rebuild before committing to an architecture
- [Idle warehouse calculator](https://hikmahtechnologies.com/idle-warehouse-calculator/): What a Snowflake warehouse that is queried faster than its auto-suspend window costs you — the most common expensive misconfiguration in an audit
- [warehouse-teardown](https://github.com/hikmahtech/warehouse-teardown): Open-source read-only CLI that answers five of the 18 audit questions from Snowflake's own metadata and prints the rest as a checklist
- [Local-First Analytics (book)](https://hikmahtechnologies.com/book/): The book on running analytics without a cloud warehouse; chapter one is free to read on-site

## Proof — verifiable claims, not testimonials

- [Systems](https://hikmahtechnologies.com/systems/): The live systems behind every number quoted on this site, with the architecture that produces them
- [AEGIS](https://hikmahtechnologies.com/aegis/): A personal AI operations system: 51 workflow types over 79 permission-gated tools
- [AEGIS: how it works](https://hikmahtechnologies.com/aegis/how-it-works/): The permission model, the approval gates and the failure handling, in detail

## Services

- [Data Platform Audit](https://hikmahtechnologies.com/services/data-platform-audit/): In one week: exactly what to fix, what to cut, and what your data platform should cost
- [Data Platform Build](https://hikmahtechnologies.com/services/data-platform-build/): Ingestion to warehouse to dashboards in weeks — for less than a hire's signing bonus
- [AI Automation Build](https://hikmahtechnologies.com/services/ai-automation-build/): LLM workflows in real operations, with a human approval gate

## Products

Hikmah Technologies owns and operates all of these. Each runs its own business on its
own domain; the on-site page explains what it is and what claim it stands as evidence for.

- [aeocue](https://hikmahtechnologies.com/products/aeocue/): Get named when your customers ask an AI — live at https://aeocue.com
- [Ansaar](https://hikmahtechnologies.com/products/ansaar/): AI-powered Shariah-compliant investing platform — live at https://ansaar.in
- [Domain Posture](https://hikmahtechnologies.com/products/domain-posture/): Audit-grade domain hygiene reports — live at https://domainposture.com
- [Quantamental](https://hikmahtechnologies.com/products/quantamental/): Global macro & central-bank credibility analytics — live at https://quantamentry.com
- [KoyraCloud](https://hikmahtechnologies.com/products/koyracloud/): Open-source self-hosted PaaS for Docker Swarm — live at https://koyracloud.com

aeocue is sold from this domain: Hikmah Technologies is the seller of record for it
(GSTIN 27AHDPA9121G1ZQ), so its subscription checkout lives here while the brochure
stays on aeocue.com.

- [Start with aeocue](https://hikmahtechnologies.com/aeocue/subscribe/): Subscribe to aeocue: ₹4,999/month founding rate per business location (₹14,999 list), locked six months, cancel any time with one message

## Case studies

- [UK capital-markets research platform](https://hikmahtechnologies.com/case-studies/uk-research-platform/): Core data system for a UK equity-research platform
- [Sehati](https://hikmahtechnologies.com/case-studies/sehati/): An audit platform where every action is traceable
- [VC Solutions](https://hikmahtechnologies.com/case-studies/vc-solutions/): Lead-generation website for an industrial solvents business
- [Manas Realty](https://hikmahtechnologies.com/case-studies/manas-realty/): Marketing website for an established real-estate firm

## Writing

Every post is written from systems I actually run. This blog is the canonical copy —
syndicated versions elsewhere point their canonical tag back here.

- [dbt with DuckDB: a warehouse that costs nothing](https://hikmahtechnologies.com/blog/dbt-with-duckdb/): dbt-duckdb pairs DuckDB's engine with dbt's models, tests and lineage. The project setup that works, run end to end, plus the limits worth knowing first.
- [dbt MCP server: what to let an agent do with it](https://hikmahtechnologies.com/blog/dbt-mcp-server/): dbt Labs ships an Apache 2.0 MCP server for dbt. Setup takes ten minutes; the real decision is which tool groups you leave switched off.
- [Why AEGIS moved off my local GPU — and still runs on yours](https://hikmahtechnologies.com/blog/why-aegis-moved-off-my-local-gpu/): I ran my personal AI system's thinking on an 8GB GPU at home for months, then moved it to Bedrock. Not because local models are bad — because my GPU is small and the work is bursty. Here are the production numbers, and why the embeddings stayed home.
- [dbt Semantic Layer: what it is and who needs one](https://hikmahtechnologies.com/blog/dbt-semantic-layer-explained/): Define a metric once in YAML and MetricFlow compiles it to SQL. Free to define under dbt Core; the APIs and BI integrations need a paid dbt plan.
- [Your Alerts Have No Identity](https://hikmahtechnologies.com/blog/your-alerts-have-no-identity/): Eight open tasks for one failing probe, and thirteen dedupe schemes that disagreed. How I rebuilt AEGIS's alerting so a problem has a record of its own before any ticket exists — and the three things production changed about it afterwards.
- [A Pile of Documents Is Not Knowledge](https://hikmahtechnologies.com/blog/a-pile-of-documents-is-not-knowledge/): My research agent had indexed 20,400 documents. Prompts had used 78 of 10,284 PDFs. Here's what measuring retrieval instead of ingestion changed — and why the fix wasn't a better filter, it was storing less.
- [A Ledger Is Not a Database Table](https://hikmahtechnologies.com/blog/a-ledger-is-not-a-database-table/): My finance agent read 200 characters of each email and called it accounting. Rebuilding it on a plain-text double-entry journal, with Postgres demoted to an index, fixed the numbers, cut the lane's model calls by 71% and caught a bug that kept paid bills open forever.
- [SQLMesh vs dbt: what it fixes, and what it costs](https://hikmahtechnologies.com/blog/sqlmesh-vs-dbt/): dbt is the default and the ecosystem. SQLMesh is better engineering for dev environments, incremental state and real SQL parsing. Who should actually switch.
- [Polars vs Pandas: the three differences that matter](https://hikmahtechnologies.com/blog/polars-vs-pandas-three-differences/): Lazy execution, no hidden copies, and parallelism by default. What each one changes in practice, why the speed claims are softer than the marketing, and when DuckDB is the better answer than either.
- [Parquet vs CSV: what you actually save, and why](https://hikmahtechnologies.com/blog/parquet-vs-csv-what-you-actually-save/): Parquet is smaller and faster than CSV for three mechanical reasons, not because it is magic. What the compression ratio depends on, why the speed gap collapses on a warm cache, and when CSV is still the right answer.
- [DuckDB vs ClickHouse: which one, and when you need both](https://hikmahtechnologies.com/blog/duckdb-vs-clickhouse/): DuckDB is an engine inside your process; ClickHouse is a server built for many concurrent queries on fresh data. How to choose, and why teams run both.
- [dbt Core vs dbt Cloud: what you actually pay for](https://hikmahtechnologies.com/blog/dbt-core-vs-dbt-cloud/): dbt Core is free and does the transformation. dbt Cloud sells scheduling, CI, an IDE, docs and governance — so compare it with Core plus what you self-host.
- [Data warehouse consulting: what you are buying](https://hikmahtechnologies.com/blog/data-warehouse-consulting-what-you-are-buying/): A buyer's guide from someone who sells it: the three engagement shapes, what each should cost and deliver, the questions to ask, and when to hire nobody.
- [Market regime detection in production: what the model actually changes](https://hikmahtechnologies.com/blog/market-regime-detection-in-production/): A three-state hidden Markov model runs daily inside my trading system. Three features, four indices, a monthly retrain, and one rule that decides whether the regime is allowed to touch a position at all. This is what it does, and what it is not allowed to do.
- [DuckDB as an LLM cache: what to cache, what to key on, and where it breaks](https://hikmahtechnologies.com/blog/duckdb-as-an-llm-cache/): DuckDB works as an LLM response cache when one process owns it, and the SQL over the cache is the reason to pick it. The three kinds of cache, the single-writer rule, the key that stops you serving a retired model's answers, and measured numbers for exact, brute-force and HNSW lookups.
- [DuckDB vs Polars: SQL engine or DataFrame library](https://hikmahtechnologies.com/blog/duckdb-vs-polars/): They are in the same speed class, so speed should not decide it. The real split is SQL and a database file against Python expressions inside your pipeline.
- [DuckDB vs Postgres: a division of labour, not a choice](https://hikmahtechnologies.com/blog/duckdb-vs-postgres/): Postgres is the system of record. DuckDB is the analytical engine. Why big scans hurt on a row store, and the three ways to run both together.
- [ClickHouse vs Postgres: when to add an analytics database](https://hikmahtechnologies.com/blog/clickhouse-vs-postgres/): Postgres is the system of record. ClickHouse is the analytics engine. When Postgres is still enough, what bites when you move, and how to run both together.
- [DuckDB vs SQLite: pick by workload, not speed](https://hikmahtechnologies.com/blog/duckdb-vs-sqlite/): SQLite handles your app's reads and writes. DuckDB answers questions about them. What actually decides it, and how to query a SQLite file with DuckDB.
- [Running DuckDB on your own infrastructure: a production setup](https://hikmahtechnologies.com/blog/running-duckdb-on-your-own-infra/): How to set up DuckDB on a server you control for faster queries — memory and temp-dir settings, Parquet layout, the read-only fan-out pattern, containers, and the mistakes that make a single node look slow.
- [Is DuckDB safe for production? The honest limitations](https://hikmahtechnologies.com/blog/is-duckdb-safe-for-production/): DuckDB is production-ready for a specific shape of workload and genuinely unsafe for another. The single-writer model, durability semantics, memory behaviour and version compatibility — what actually bites, and how to design around it.
- [Can DuckDB be your SaaS product's warehouse? Where the ceiling actually is](https://hikmahtechnologies.com/blog/duckdb-as-a-saas-warehouse/): For a small SaaS, a single-node engine over Parquet handles more than founders expect. The three questions that decide whether it fits, what customer-facing analytics needs, and the specific point where you outgrow it.
- [What a data pipeline actually costs: build, run, maintain](https://hikmahtechnologies.com/blog/what-it-costs-to-build-a-data-pipeline/): What drives the build cost of a data pipeline, what it costs to run and maintain afterwards, how managed-ETL pricing models compare with building your own, and the shapes I see by funding stage.
- [What data engineering actually costs, and how I price it](https://hikmahtechnologies.com/blog/what-data-engineering-costs-and-how-i-price/): The full rate card — audit, build, AI workflow, fractional — with the numbers in USD, plus why builds are scoped ranges instead of a day rate.
- [DuckDB vs Snowflake: the 4 questions that decide it](https://hikmahtechnologies.com/blog/duckdb-vs-snowflake/): DuckDB wins when the working set fits one machine and few people query at once. Snowflake wins on concurrency and governance. What switching really costs.
- [Data engineering consultant vs. full-time hire: an honest breakdown](https://hikmahtechnologies.com/blog/data-engineering-consultant-vs-full-time-hire/): The real fully-loaded cost of a full-time data engineer, when a consultant is the better call, and how to tell which one your situation actually needs.
- [How to connect an LLM to your database, safely](https://hikmahtechnologies.com/blog/connect-llm-to-database-safely/): The four ways to wire an LLM to your data — MCP, text-to-SQL, a semantic layer, function calling — and the guardrails that stop the demo becoming an incident.
- [ClickHouse vs Snowflake: cost, speed and SQL compared](https://hikmahtechnologies.com/blog/clickhouse-vs-snowflake/): ClickHouse wins on steady, sub-second analytics if you will operate it; Snowflake wins on mixed ad-hoc SQL with zero ops. Cost models, SQL feature gaps, streaming and migration, compared by someone who runs ClickHouse in production.
- [Chat with your database: a practical guide, not a product pitch](https://hikmahtechnologies.com/blog/chat-with-your-database/): What it takes to make natural-language querying actually useful for non-technical teams — the schema semantics, guardrails and verification the demos skip.
- [How I built a paid-grade data product on 100% free public data](https://hikmahtechnologies.com/blog/paid-grade-data-product-on-free-public-data/): A teardown of a macro data product: 171 countries scored daily from 10 free public data sources, point-in-time correct, with the licensing and cost work done.
- [LLM agents in production: a teardown of AEGIS, my open-source automation layer](https://hikmahtechnologies.com/blog/llm-agents-in-production-aegis-teardown/): Four LLM agents, 28 Temporal workflows, every risky action behind a human approval gate. An architecture teardown of AEGIS — and what it teaches about production AI automation.
- [Building a data platform solo: the Ansaar teardown](https://hikmahtechnologies.com/blog/building-a-data-platform-solo-ansaar-teardown/): NSE and crypto ingestion, ClickHouse, LightGBM, backtests and a Prolog compliance layer — a self-hosted data platform built and run by one person.
- [AEGIS Is Open Source](https://hikmahtechnologies.com/blog/aegis-is-open-source/): Three months ago I wrote about my personal AI orchestration system and ended with a section titled 'Why It's Not Open Source Yet.' That's fixed. AEGIS is on GitHub, MIT-licensed — here's what it actually took to get there.
- [Behavior Is Data, Not Code](https://hikmahtechnologies.com/blog/behavior-is-data-not-code/): The biggest refactor of the AEGIS open-sourcing sprint: removing every branch on an agent's identity so behavior lives in the database as capability tags — resolved at runtime, edited from a UI, and safe even when a tag has no owner.
- [A To-Do Is a Tweet: Social Publishing With Approval Cards](https://hikmahtechnologies.com/blog/a-todo-is-a-tweet/): Scheduling a social post doesn't need a new UI. A to-do already has copy, a time, and labels — so in AEGIS, a Todoist task with a publish label is a scheduled post, and nothing goes out until a card in chat gets a human tap.
- [Bring Your Own Cloud: The Infrastructure Registry](https://hikmahtechnologies.com/blog/bring-your-own-cloud-infrastructure-registry/): For a self-hosted system that's meant to be forked, there's exactly one honest way to handle infrastructure credentials: the user brings their own, the system stores them encrypted, and nothing in the code assumes a vendor. Here's how AEGIS got there — and what it cost me to cut my own vendors out.
- [Labels, Not Projects: Rethinking GTD](https://hikmahtechnologies.com/blog/labels-not-projects-rethinking-gtd/): The day Next and Someday stopped being Todoist projects and became labels — and why that small modelling decision is what made AEGIS's GTD layer, and its bidirectional sync, actually work.
- [Day One of Opening the Box](https://hikmahtechnologies.com/blog/day-one-of-opening-the-box/): AEGIS is going open source, and today the first public commits landed. Day one of turning a private system into a shippable one: twenty-seven migrations squashed into a baseline, credentials evicted from the build, and an admin panel redesigned around decisions.
- [Your Snowflake bill is mostly overhead](https://hikmahtechnologies.com/blog/your-snowflake-bill-is-mostly-overhead/): If you're paying thousands a month to query tens of gigabytes, you're renting a freight train to carry a backpack. Here's how to tell, and what to do instead.
- [When the Bot Learns to Stay Quiet](https://hikmahtechnologies.com/blog/when-the-bot-learns-to-stay-quiet/): AEGIS watches my homelab and GitHub, but the interesting part is what happens between an alert firing and me hearing about it. Most of the time, the correct answer is nothing.
- [DuckDB in production: what it's actually good at (and what it isn't)](https://hikmahtechnologies.com/blog/duckdb-in-production-what-its-good-at/): Is DuckDB production-ready? Where it shines, the workloads it fits, and the deployment patterns that work — from someone who ships it.
- [Do you actually need a data warehouse?](https://hikmahtechnologies.com/blog/do-you-actually-need-a-data-warehouse/): A short, honest decision framework for the question every data team eventually faces — before you sign a five-figure annual contract for infrastructure your data might not need.
- [Ask your database in plain English — locally](https://hikmahtechnologies.com/blog/ask-your-database-in-plain-english-locally/): A small SQL-tuned model running on your machine can convert plain English questions into correct SQL. No API keys, no data leaving your laptop, no vector database.
- [Local-first analytics in practice: DuckDB, Parquet, and killing the round-trip](https://hikmahtechnologies.com/blog/local-first-analytics-in-practice-duckdb-parquet/): A concrete walkthrough of the local-first pattern: query Parquet directly with DuckDB, no warehouse, no server, no per-query bill — from a notebook or the browser.
- [Calling an LLM from inside a SQL query](https://hikmahtechnologies.com/blog/calling-an-llm-from-inside-sql/): Run a model directly in SQL to classify rows, extract text fields, or summarize data without exporting. Here's where it works, what it costs, and when not to bother.
- [Why I wrote Local-First Analytics](https://hikmahtechnologies.com/blog/why-i-wrote-local-first-analytics/): Most analytics stacks are cloud round-trips solving problems that fit on a laptop. Local-first analytics is the case for bringing the compute back to the data — and to the user.
- [Turning messy PDFs into clean tables, on your own machine](https://hikmahtechnologies.com/blog/messy-pdfs-to-clean-tables-locally/): Parse PDFs to markdown, extract structured data with a local model and strict validation schema, no API needed.
- [Connecting an AI assistant to your database with MCP — without letting it do damage](https://hikmahtechnologies.com/blog/connect-an-ai-assistant-to-your-database-with-mcp/): Use the Model Context Protocol to let Claude explore your data in plain English. The whole game is permissions: read-only role, standard server, 90% of the value with almost none of the risk.
- [Search your documents without a vector database](https://hikmahtechnologies.com/blog/search-your-documents-without-a-vector-database/): Most teams reach for Pinecone or Weaviate the moment they hear semantic search. For a team-sized knowledge base, you don't need one. Your database already has what you need.
- [Letting Claude Code write your dbt models — and why you still read every line](https://hikmahtechnologies.com/blog/letting-claude-code-write-your-dbt-models/): Claude Code can run dbt in a loop, read errors, and fix them. It needs you to steer grain, business logic, and naming — and to review the tests it writes.
- [Using an LLM to catch the data quality problems your tests can't](https://hikmahtechnologies.com/blog/llm-as-judge-for-data-quality/): Structural tests catch NOT NULLs and schema errors. Semantic problems—does this description match its category?—need a judge. How to use one responsibly.
- [Should there be an LLM in your data pipeline?](https://hikmahtechnologies.com/blog/should-there-be-an-llm-in-your-pipeline/): An LLM is probabilistic, slow, and costly. Here's how to decide whether it belongs in your pipeline — and where it clearly doesn't.
- [Local model or paid API? The honest math for data work](https://hikmahtechnologies.com/blog/local-model-or-paid-api-the-honest-math/): When does running an open-weight model on your own hardware beat paying per token? The answer depends on volume, frequency, and whether you have real privacy constraints.
- [Generating realistic test data with a local model](https://hikmahtechnologies.com/blog/generating-test-data-with-a-local-model/): How to harden a data pipeline by feeding it carefully generated edge cases, using a local LLM when simpler generators aren't enough.
- [When local-first runs out of road](https://hikmahtechnologies.com/blog/when-local-first-runs-out-of-road/): Local-first, file-based data has a real ceiling. Most teams never reach it. When you do, here's what actually changes.
- [Running a local model over millions of rows without it falling over](https://hikmahtechnologies.com/blog/running-a-local-model-over-millions-of-rows/): Batching, checkpointing, and idempotency are what make local inference scale. Get these right and a single GPU chews through millions of rows overnight.
- [One Primitive for Every Interruption](https://hikmahtechnologies.com/blog/one-primitive-every-interruption/): The design decision in AEGIS I'm proudest of isn't an agent or a model — it's a single interactions primitive. How one Postgres table, five kinds of card, and a Temporal workflow replaced every per-domain approval pattern.
- [Meet AEGIS: My Weird Little Operating Layer](https://hikmahtechnologies.com/blog/meet-aegis-my-weird-little-operating-layer-3087a3e616d4/): AEGIS is my personal operating layer: four agents that watch my inbox, repos, alerts and feeds, and bring a proposed next step instead of a notification.
- [Building with Claude Code: Faster Iteration, Faster Drift](https://hikmahtechnologies.com/blog/building-with-claude-code-faster-iteration-faster-drift-480a646e6f3c/): Claude Code made my AEGIS v3 rewrite fast. The honest part is what got harder: drift, verification and knowing when to stop. The developer stays hands-on.
- [Building AEGIS: How Prolog + a Knowledge Graph Make Local LLMs Actually Useful](https://hikmahtechnologies.com/blog/building-aegis-how-prolog-a-knowledge-graph-make-local-llms-actually-useful-5cc5217783d2/): Prolog and a knowledge graph take routing, classification and fact lookup off the LLM, so most of a personal AI system runs on a cheap local model.
- [Market Regime Detection: From Hidden Markov Models to Wasserstein Clustering](https://hikmahtechnologies.com/blog/market-regime-detection-from-hidden-markov-models-to-wasserstein-clustering-6ba0a09559dc/): Market regimes differ in volatility and correlation, not just direction. Detecting them with hidden Markov models and Wasserstein clustering, with code.

## Contact

- Email: info@hikmahtech.in
- Book a 30-minute call: https://calendly.com/arshad-hikmahtechnologies/30min
- Location: Navi Mumbai, India — working with clients in the US, EU and India