Mohammad

2x Startup Founder | AI, Cloud Computing | Building in Public

[Mohammad @AminTechnical]

Avengers Vs. Messengers
Let's teach our children:
Before Iron Man, there was Dawood Alayhis Salaam, the one who could bend iron and metal with his bare hands.
[Qur'aan 34:10].
...

[Mohammad @AminTechnical]

docker was supposed to simplify deployments. now every team has a dedicated devops person just to debug containers. the tool that promised "run anywhere" created a whole new class of problems. is your container strategy actually simpler or just different complexity?

[Mohammad @AminTechnical]

shipped a quiet feature last night that took 3 weeks to get right.

context: our AI agents often got stuck in loops, retrying the same failed task 20+ times. burning credits. no visibility.

so we built a circuit breaker with exponential backoff and real-time alerts.

here's what it does →

→ Detects stuck agents (3+ retries on same task)

→ Auto-pauses after threshold with exponential backoff

→ Sends Slack alert with error context

→ Logs everything to observability dashboard

→ Resume button in dashboard (no redeploy needed)

the result?

our agent failure rate dropped 60% overnight. credit burn dropped 40%. and I finally sleep through the night without checking dashboards.

sometimes the unsexy infrastructure work saves you more money than the flashy features.

[Mohammad @AminTechnical]

AI wrappers are the new mobile apps.

Remember 2010? Everyone was building an app for everything. "There's an app for that" was a meme. 90% were just websites wrapped in a UIWebView.

Now it's 2026 and we're doing the exact same thing with LLMs.

→ Same API call, different Tailwind skin
→ Same system prompt, different feature flag
→ Same rate limits, different pricing page

The difference? Mobile app saturation took 5 years. AI wrapper saturation took 6 months.

If your entire moat is "we have a nice UI over GPT-4," you don't have a moat. You have a feature waiting to be absorbed.

Build infrastructure. Own the stack. Solve problems that don't disappear when OpenAI ships a new model.

The winners aren't building wrappers. They're building the rails everyone else runs on.

[Mohammad @AminTechnical]

@ApplyWiseAi no tool registry yet but that's the plan. want to build a pattern library so when it sees "AccessDenied" on iam:PassRole for the 10th time, it doesn't re-derive the fix from scratch.

early version but it already handles around 80% of common ECS/IAM failures without intervention.

[Mohammad @AminTechnical]

just shipped something I've wanted for months

our NayaCloud agents can now self-heal when tasks fail

here's what that means →

agent tries aws deploy → hits permission error → instead of dying, it:
→ reads the error
→ figures out the missing iam role
→ writes a fix
→ retries the deploy
→ logs exactly what happened

no human intervention. no 2am slack alerts.

why this matters:

most agent platforms treat failures as "restart the task and pray"

we built retry logic that actually understands what went wrong

still testing edge cases but the early results are solid

this is the difference between "AI that helps you work" and "AI that works while you sleep"

[Mohammad @AminTechnical]

I ran AI agents on Fargate Spot for 30 days straight. Here's what the bill looked like:

→ 3 agents running 24/7
→ Total compute cost: $23.40
→ Same setup on regular Fargate: $87
→ Savings: 73%

The catch? Your containers can get terminated mid-task. But here's the fix — design your agents to checkpoint state every 60 seconds. When Spot kills the task, the next instance picks up exactly where it left off.

Most people skip Spot because they think it's too complex. It's not. The real cost is 10 minutes of upfront work on retry logic.

If your AI agent doesn't recover from interruption, it's not production-ready anyway.

[Mohammad @AminTechnical]

Your AI agent costs aren't the problem. Your architecture is.

Most founders I've talked to are paying 3-5x what they should for AI agent hosting. Same workload, same results, different bill.

Here's my exact cost breakdown running 24/7 agents →

→ LLM inference: 60% (tough to cut here)
→ Compute (Fargate): 25% (easy wins)
→ Storage & network: 10% (quick fixes)
→ Logging & monitoring: 5% (often forgotten)

The real move isn't switching providers. it's using spot instances smarter.

→ Run stateless agents on spot → 70% savings
→ Move persistent state to cheap object storage
→ Use ARM Graviton instead of x86 → 20% cheaper
→ Route non-urgent tasks to off-peak hours

Most "AI infrastructure" companies won't tell you this because they charge premium for the same AWS resources.

I run a 12-agent fleet for under $90/month. Each agent handles ~1000 tasks/day.

Build the cost sensitivity into your system from day one. Your future self will thank you.

[Mohammad @AminTechnical]

Stop writing prompts from scratch.

I spent 6 months refining these AI prompts for dev workflows. Saved me 50+ hours:

→ Code Review Agent — paste a PR, get structured feedback in 30s

→ Refactor for Performance — "optimize this function for O(n) → O(log n)"

→ Architecture Decision — describe your problem, get 3 approach options with trade-offs

→ Debug Stacktraces — paste an error, get likely causes + fixes ranked by probability

→ Generate Tests — "write unit tests for this function with edge cases"

→ API Design Review — describe your endpoint, get REST best practice feedback

The secret: treat AI like a junior dev who needs context, not a mind reader.

Which one are you using?

[Mohammad @AminTechnical]

your AI agents are running. but do you actually know what they're doing?

we weren't. and it almost cost us.

last week an agent loop ran for 6 hours straight burning tokens on a task that should've taken 40 seconds. no alert. no kill switch. just a growing bill.

so we built observability into the NayaCloud agent pipeline from scratch. here's what we track now →

→ token spend per agent per task (real-time)
→ task duration vs baseline (auto-flag anomalies)
→ retry loops detected and killed after 3 cycles
→ cost ceiling per agent run ($0.50 default, configurable)
→ dead-letter queue for failed tasks (inspect later, don't lose work)

the unsexy truth about AI agents: the hard part isn't making them work. it is keeping them from silently failing in production.

if you're deploying agents without observability, you're flying blind with someone else's credit card.

building this in public → follow along..

[Mohammad @AminTechnical]

Building a thin UI around OpenAI and calling it an "AI startup" is a dangerous game.

It's not a business. It's a feature waiting to be absorbed by the next foundational model update.

If your entire value prop can be replaced by a well-written Claude system prompt, your moat is zero.

The companies that survive the next 12 months aren't selling the model. They're selling the workflow.

→ Proprietary data integrations
→ Friction-less distribution channels
→ Highly specific vertical context
→ Deeply integrated agentic actions

Stop competing on LLM outputs. Start competing on what the LLM is connected to.

[Mohammad @AminTechnical]

I just migrated our AI agent fleet off AWS and cut our infrastructure bill by 70%.

Everyone defaults to AWS Fargate for containerized agents, but the math for always-on AI workers is brutal.

Here is exactly how we restructured our stack for maximum efficiency:
→ Moved from Fargate Spot to Hetzner dedicated bare metal for raw compute
→ Kept managed DBs on AWS (RDS) for reliability via a secure Tailscale connection
→ Dropped our container compute cost from $0.04/vCPU-hour to pennies
→ Deployed Docker Swarm to handle container orchestration automatically

Stop paying premium cloud taxes for raw compute. You don't need hyperscaler elasticity for steady-state AI background workers.

[Mohammad @AminTechnical]

@mscode07 https://t.co/DPUrtP7A4P

[Mohammad @AminTechnical]

shipped a massive update to the NayaCloud agent pipeline this weekend.

instead of spinning up heavy containers for every task, we moved entirely to a dynamic spot-fleet model.

here is what we achieved in 48 hours:
→ cut idle compute costs by 82%
→ reduced agent startup time from 12s to 1.5s
→ built a custom memory bridge for long-running autonomous tasks

building AI infrastructure isn't glamorous. it's mostly reading AWS docs at 2am. but it's the only way to survive when compute costs start stacking up.

who else spent the weekend shipping?
#buildinpublic #AIagents

[Mohammad @AminTechnical]

most developers are still coding AI agents the hard way.

these 6 open-source tools replaced $300/mo in paid services for me →

→ Ollama — run Llama 3, Mistral, Gemma locally. zero API costs for dev/test. I prototype every agent offline first.

→ LiteLLM — one interface, 100+ LLM providers. swap models with a single env var. no vendor lock-in ever again.

→ Portkey — AI gateway with fallbacks, caching, and rate limiting. cut our token spend by 35% just from response caching.

→ Langfuse — open-source LLM observability. traces every agent call so you actually know what's eating your budget.

→ Dify — visual agent builder for non-eng teammates. our ops team builds internal automations without touching code.

→ MinIO — self-hosted S3. storing agent artifacts on a $6/mo Hetzner box instead of paying AWS storage markup.

the pattern: self-host what you can, use managed only where uptime is critical.

building AI products doesn't have to cost $500/mo before you have a single user.

[Mohammad @AminTechnical]

Everyone's running AI agents on Lambda and wondering why their bill is $400/mo

Meanwhile I'm running the same workloads on Fargate Spot for $0.06/hr

Here's the actual breakdown →

→ GPU inference: offloaded to Hetzner dedicated ($45/mo flat)
→ Orchestration: Fargate Spot with graceful interruption handling
→ Storage: S3 Intelligent-Tiering (auto-moves cold data)
→ Monitoring: CloudWatch + a custom agent that alerts before spend spikes

Total: ~$87/mo for always-on agent infra

The trick most people miss: you don't need GPU on every node. Only the inference layer needs it. Everything else runs fine on ARM Graviton instances at half the price.

Stop throwing money at managed AI platforms. Learn where compute actually matters.

[Mohammad @AminTechnical]

@mscode07 https://t.co/rxxt4fX19G

[Mohammad @AminTechnical]

@FabianXR_Builds https://t.co/rxxt4fX19G

[Mohammad @AminTechnical]

Most "AI startups" are just OpenAI API calls with a Tailwind UI. They won't survive the next major model update.

If your entire business relies on generic prompt engineering, you don't have a moat, you have a feature waiting to be Sherlocked.

The companies that actually make it will do the hard work:
→ Building specialized, proprietary data pipelines
→ Fine-tuning models on domain-specific edge cases
→ Owning the entire infrastructure layer

Stop wrapping APIs and start building actual software businesses. The easy money phase is over.

[Mohammad @AminTechnical]

@BatsouElef https://t.co/DPUrtP87Un

[Mohammad @AminTechnical]

@heyblake https://t.co/DPUrtP87Un