Grounded interpretation
Reading incomplete, multi-order emails into structured facts, keeping the source of every fact, and separating what is known from what still needs a question or a human decision.
Sathwik Mamidi
I build AI systems for work where mistakes are expensive.
Technical founder. I have been building products since 2017 and launching them since 2018, across applied AI, developer infrastructure, identity, and real-time systems. Today I am co-founder and CTO of Akisto, an AI supplier coordinator already running inside a manufacturer’s procurement team.
- Current role
- Co-founder and CTO, Akisto
- First product launch
- 2018
- Products built
- 15 including Akisto
- Owns
- Architecture, engineering, AI, infrastructure
- Reach me
- hi@sathwikmamidi.com
Now
Akisto
Co-founder and CTO. An AI supplier coordinator for manufacturers.
Between a purchase order and its delivery, manufacturers chase suppliers through email and phone calls that mix several orders, answer half the question, and move dates without saying so. Akisto automates that work: traceable facts from every conversation, a consistent state for every order, and follow-up that happens on time.
I lead product and engineering end to end: system architecture, AI agents that work with suppliers over email and phone, workflow automation, integrations, data pipelines, and a risk layer that flags the orders most likely to disrupt production. My co-founder brings years of manufacturing operations and procurement consulting; my job is to turn that knowledge into systems that hold up in production.
Akisto has run live supplier follow-ups on 2,000+ purchase orders for a manufacturer. I extended the workflow system behind that pilot and am building the production platform on TypeScript, PostgreSQL and Temporal.
- Role
- Co-founder and CTO
- Pilot
- Live with a manufacturer
- Purchase orders
- 2,000+ in pilot
- TypeScript
- React
- PostgreSQL
- Temporal
- AWS
Supplier conversationsEmail, calls, updates, and commitments
AI interpretationStructured facts, linked to sources
Deterministic business rulesCanonical order state
Durable workflowsFollow-up and recovery
Human oversightApproval and escalation
The hard problems I own
Coordination over weeks
Tracking commitments, partial shipments, silent suppliers, and buyer interventions across days or weeks, with recovery that never sends a duplicate action or an out-of-date follow-up.
A foundation that holds
Tenant isolation, a full audit trail, and observability for the production platform, informed by live supplier follow-up workflows at a manufacturer.
Track record
From idea to working software.
I founded or co-founded the products and projects below, owning their technical foundations from architecture through implementation.
-
2026
Akisto
Co-founder and CTO · July 2026–present
AI supplier coordination for manufacturing procurement teams. Live supplier follow-ups on 2,000+ purchase orders for a manufacturer, on the workflow system I extended. I am building the production platform on TypeScript, PostgreSQL and Temporal.
-
2025–26
Scrute
Co-founder and CTO · October 2025–June 2026
AI document intelligence for commercial real estate. Title commitments reconciled against ALTA surveys and plan sets checked against building-code rules, with every finding tied to its source. Customer discovery moved the focus from title review to permit compliance.
-
2025
Aiditor
Co-founder and CTO
A conversational editor for image, audio, and video that replaces a timeline with a request. I built the complete product from scratch, through to launch readiness.
-
2016–25
Independent
Founder
Independent product development across AI, developer tools, SaaS, consumer software and real-time games. Selected work includes later independent and personal/open-source projects.
Aftlog (2026): A local-first Rust flight recorder for AI coding agents. Records commands and file changes against a Git baseline and produces session reports with conservative, backup-first recovery plans. Open source.
Everby (2026): A native macOS accountability companion in Swift and AppKit, with layered memory, voice input, activity-aware check-ins, local state and Keychain-stored credentials. Open source.
Authnest: Identity and email infrastructure built solo through three product generations, from social login and enterprise authentication to a dedicated inbox for app logins and notifications. Built a serverless AWS pipeline using SES, S3, Lambda and DynamoDB to turn inbound email into structured application records.
Commentrix: An AI sports-commentary prototype built solo, from idea to working MVP in two weeks. Combined video analysis, timestamped play-by-play, voice synthesis and aligned subtitles. Gathered informal feedback from US university students and alumni and demonstrated it to one UAE video platform.
SlowAndSteady.io: A zero-player multiplayer browser race with live WebSocket updates and a Redis-backed leaderboard. Built solo and reached 13,000 active users.
OnlyOnePremium: A unified subscription and shared-login layer across independent websites and paid software products.
Rank Race: A multiplayer racing game combining incremental progression with real-time races, built with Unity, C#, sockets and Redis.
Favs.bio: Public profiles built around interests and discovery.
Vowalls: A community platform for publishing and voting on opinions, built with Python, Flask and MySQL.
Selected engineering
The decisions behind the systems.
Four systems I designed and built, with the trade-offs that shaped them and the source wherever it is public.
Aftlog
A flight recorder for AI coding agents.
A coding agent can rewrite a codebase in one session, faster than anyone can review it. Aftlog is a local Rust daemon that records commands and file changes, separates the agent’s work from what was already there, and turns the session into a readable report with a conservative revert plan.
- Rust
- Git
- Filesystem watchers
Engineering decisions
Establish a baseline before capture. Aftlog records the starting Git state and bounded filesystem snapshots, so session changes can be reviewed separately from pre-existing work. Hook-based session startup waits for that baseline before acknowledging capture.
Let uncertainty shape recovery. Low-confidence paths are excluded from the default reverse patch. Applying a revert requires confirmation and creates a backup branch plus a working-tree patch; files outside Git use a separate restore plan.
Bound the cost of observation. Snapshot walks cap file counts and total shadow-copy storage, skip symbolic links, and report incomplete coverage. Finished sessions prune shadow copies that are no longer needed.
$ aftlog record -- codexCapture. Commands, file changes, Git baseline.
$ aftlog report lastInspect. Readable receipt and session diff.
$ aftlog revert-plan lastReview recovery. Explicit review before any revert.
Scrute
Document review that cites its sources.
Commercial real estate deals stall on review work that is high-stakes, repetitive, and still done by hand because nobody trusts software to get it right. I built TitleCheck AI to reconcile title commitments with land surveys, and PermitCheck AI to read architectural plans against a defined set of building-code rules.
- TypeScript
- NestJS
- PostgreSQL
- Gemini
- Next.js
Engineering decisions
Parse independently, reconcile together. TitleCheck runs title and survey parsing in parallel, then compares the extracted exceptions and annotations. Variances retain links to the underlying records for review.
Separate vision from rule evaluation. PermitCheck extracts dimensions and plan context with a vision model, then runs explicit TypeScript rules. Findings include the rule, observed and required values, confidence, and page references.
Persist a coherent result. Extractions, findings, relationships, and processing status are saved together in a PostgreSQL transaction. Document storage and model calls happen outside that database transaction.
Title commitmentLand surveyPlan set
Parallel extractionExceptions, annotations, dimensions
Reconciliation and rulesExplicit checks, not model opinion
Reviewable findingsRule, values, and page evidence
ImageAudioVideo
Model orchestrationPlans the edit as Python
Sandboxed executionDocker, FFmpeg, media outputs
Aiditor
Conversation as the control surface for media.
Describe the result; Aiditor plans the edit, writes the code, runs it in an isolated container, and returns finished files. I built the whole product: orchestration, sandboxed execution, media processing, authentication, storage, and billing.
- Python
- FastAPI
- Gemini
- Docker
- FFmpeg
Engineering decisions
Separate planning from execution. The orchestrator prepares source media and conversation context, asks the model for Python, then hands execution to a dedicated Docker container. Exit status, stdout, stderr, and returned files feed the result.
Close the loop on failure. Failed code and execution logs are added back to the model’s context for another attempt, with a maximum of three attempts. Redis-backed task status exposes preparation, generation, and execution progress.
Carry media through the entire product. The application connects chat state, file metadata, S3 storage, authentication, and billing. Generated files are retrieved from the execution container and associated with the response.
Implementation: orchestration, execution.
Durable factsWhat persists
SummariesWhat matters
TranscriptsWhat happened
Local statemacOS Keychain
Everby
An accountability companion that remembers.
A native macOS app designed as a relationship rather than a dashboard: layered memory, voice dictation, check-ins timed to the person’s actual day, and narrow local tools for reminders and commitments.
- Swift
- AppKit
- Keychain
- Tool calling
Engineering decisions
Give context distinct lifetimes. The model receives recent conversation alongside conversation, daily, and weekly summaries. Durable facts live in a separate store and can be corrected, deactivated, or deleted.
Schedule around actual activity. Check-ins use the user’s first active time, configurable intervals, a daily limit, and an evening anchor. In-flight notification keys prevent overlapping generation; regular check-ins defer when the model is unavailable.
Keep storage and credentials separate. Personal state is persisted locally, while the API key is stored in macOS Keychain. AppKit notifications support inline replies; model requests still go through an external API.
Implementation: memory store, scheduler, notifications.
Range
The same ownership, different constraints.
Building products since 2017 has meant solving very different engineering problems personally, not delegating them.
Multimodal pipelines
Commentrix samples sports footage, writes timestamped play-by-play, synthesizes narration, and aligns voice and subtitles back onto the source timeline.
Python, model orchestration, OpenCV, FFmpeg
Real-time systems
Shared state, socket communication, and authoritative multiplayer logic. Rank Race in Unity, and SlowAndSteady.io, a zero-player race launched in March 2022 that reached 13,000 active users.
C#, Unity, WebSockets, Redis
Identity and email
Authentication, transactional email, and event-driven backends. Authnest’s dedicated email identity, and a serverless pipeline that turns inbound mail into application data.
Node.js, Amazon SES, Lambda, DynamoDB
Browser automation at scale
Parallel browser workloads across cloud instances. Twish, a visual search index of one million websites, built on distributed screenshot capture.
JavaScript, Puppeteer, AWS EC2
Earlier products and tools
Products, prototypes, and utilities built since 2017. Most of what the later products needed was first learned here.
OnlyOnePremium
One subscription across independent websites and software products. It began as ad-free access to content sites and evolved into a shared login for a curated bundle of paid tools, testing where one account, one payment, and many partners meet.
Node.js, shared identity, AWS
SlowAndSteady 2
A multiplayer idle economy in which giving creates power: donating points changes future earning power. Guilds, transfers, and one global leaderboard, updated live over WebSockets with player state in Redis.
Node.js, WebSockets, Redis
Logistics Trust Console
Carrier due diligence that refuses to hide its reasons. Risk signals, evidence, policy gates, and an audit trail in one review flow, with every score explained to the operator. The public reference uses deterministic demo data.
React, Vite, explainable scoring
Open Order
A restaurant menu that responds to intent instead of presenting a database: guided discovery, contextual pairings, and a live basket. A static Next.js prototype with deterministic recommendations; checkout is disabled in the public demo.
Next.js, React, product prototype
OAuth Flow Tester
A local harness for proving OAuth and OpenID Connect authorization-code flows before they reach a real product. Handles callback state, server-side token exchange, and userinfo retrieval, and redacts tokens from browser output.
Node.js, Express, OAuth and OIDC
SES Email Ingestion
A narrow serverless boundary between raw email and application data. SES stores MIME in S3; a Lambda parses sender, recipients, bodies, and attachment metadata into a normalized DynamoDB record.
Amazon SES, S3, Lambda, DynamoDB
Voice Chat Widget
An embeddable voice and text assistant with the operational boundaries built in: request validation, upload limits, rate limiting, configurable CORS, and local fallbacks for development without model credentials.
TypeScript, Express, browser audio
Prompt Page Builder
Natural-language page generation with ownership and containment designed in. Username-scoped public pages, an owner-only editing flow, and generated HTML filtered and isolated in a sandboxed iframe.
TypeScript, Redis, HTML generation
WhoCan
A public contact page that puts boundaries before the inbox. People publish rules for which requests are worth sending; a typed backend validates and routes them to a private dashboard.
TypeScript, Express, Redis
AI Wallpaper Batcher
A command-line tool that makes generative output predictable: validated inputs, deterministic filenames, and a dry run that shows every prompt and path before a paid API call is made.
TypeScript, CLI, image generation
Links Browser
A mobile browser organized around people, films, and creators rather than tabs. Built first in React Native, then rewritten in Flutter when performance demanded it.
React Native, Flutter
SV Hunt
Timed internet scavenger hunts with hard puzzles, live releases, and prize rounds. It found a loyal audience among competitive puzzle solvers, and ran on a live game loop over Node.js, MySQL, and Redis.
Node.js, MySQL, Redis
Favs.bio
A link-in-bio rebuilt around shared interests rather than self-promotion, connecting profiles through what people actually like.
Consumer web, public profiles
Vowalls
A publishing platform where opinions were posted, contested, and voted on. My first complete web product, and where the habit of owning both interface and backend began.
Python, Flask, MySQL
Principles
How I build.
What building products since 2017 has taught me to do first, and never to skip.
Start where the work actually happens.
Before any architecture, I learn how the job is done today: the spreadsheets, the email threads, the workarounds. The real bottleneck is rarely where the pitch deck says it is.
Let models interpret. Let rules decide.
Models are good at reading messy input. Commitments, state, and money belong to deterministic code, with a person able to step in at the moments that matter.
Show the evidence, and plan the undo.
A finding, score, or automated action is incomplete without a source someone can inspect and a way back if it is wrong. Audit trails and recovery are product features.
Earn every piece of complexity.
Use the smallest architecture that tells the truth. Durable workflows and live sockets when the constraint demands them; a static page and a good data model when it does not.
I stay close to the code.
Since I began building products in 2017, I have owned both the product and the system underneath it.
I trained as an electronics and communications engineer, began learning programming in 2016, and launched my first product in 2018: consumer products and multiplayer games first, then identity, developer infrastructure, and applied AI. I built 14 products before Akisto, my 15th. Along the way I learned to find the real constraint quickly, commit to an architecture that fits it, and change course when the evidence says so.
As co-founder and CTO of Akisto, I lead product and engineering end to end. I stay hands-on in the codebase, because that is where the hardest product decisions surface first.
Full history on LinkedInFounders, operators, and engineers
Tell me about
the hard part.
If you are working on a difficult problem in a domain you know deeply, I would like to hear about it.