I'm begging you to try systems programming. I built tiny AWS - a cloud using no Docker, no VMs, just 10,000 lines of Golang and Rust code with this same mindset. Tiny AWS is legit just cli, and not even React or NextJS codes. Stop spending all your time... learning another framework, another library, another abstraction. Go figure out what actually happens underneath. - Write your own memory allocator. - Build an operating system kernel. - Implement a TCP stack. - Write a compiler. - Build a database engine. - Understand how Linux schedules processes, manages memory, handles interrupts, and talks to hardware. Learn C. Get your hands dirty with Rust. Read source code. Read the Linux kernel. Break things. Spend time debugging a segmentation fault because you forgot how pointers work. And then experience the satisfaction of finally understanding WHY something works, instead of just knowing WHICH API to call. We're entering an era where AI can generate thousands of lines of code in seconds. Frameworks are getting easier. Abstractions are getting higher. The barrier to shipping software is collapsing. But here's the interesting part: The easier it becomes to generate code, the more valuable it becomes to understand what's happening underneath it. Anyone can ask an AI to build an application. But can you explain WHt happens when a process gets created? How memory is allocated? What happens when a packet travels through a network? Why a database quEry becomes slow? Can you debug something when the abstraction leaks and the documentation stops helping? That's the difference between knowing how to use technology and understanding how to engineer it. You don't need to become a kernel developer. You don't need to abandon web development. And you certainly don't need to reinvent everything. Just spend some time building things that force you to think. Because there's something incredibly beautiful about programming when you stop treating computers as magical boxes that execute your JavaScript. Don't just learn to build software. Learn how the machine works. I'm telling you, try systems programming at least once.show more

Here's the repo

System programming changes your whole perspective towards computer science. I have been building kernel drivers and EDR sensors for the past 2 years and damn, there is so much to learn.

Every cloud service is somehow wrapper over Linux and other things providing something extra. Having root understanding of it gives more clarity of others

Docker is already built on namespaces and cgroups, so going directly to these primitives gives more control over isolation and resource limits.

YEP. I removed the middle layer and exposed how underneath basically works.

These is one of the best advice in this AI era for developers

10k lines of Go and Rust, just a CLI, no React — that's a proper tiny AWS.

What does it use for isolation without containers or VMs, plain processes with cgroups?

Yep

Skipping containers entirely is a great way to feel everything AWS quietly handles for you

looks cool

building tiny aws is the fastest way to understand why big aws charges like that

Great job but I write code to turn profit not because I enjoy learning or care about rebuilding an already built framework in the name of "learning how the machine works" Cheers

tiny aws in 10k lines with no docker is soo coool, which part was the hardest to get working, networking?

Tiny AWS is cool, but the real test is whether the bill is also tiny or still a mystery at month end

Banger

Sick of bloated tech stacks? Me too. @shubhamm069 nails it. Simplicity rocks, especially when it's a homebrewed AWS. Building a CLI cloud from scratch? Now that's spirit!

The best explanation

Agree with the spirit. Even one small project like a key-value store or an HTTP server on raw TCP changes how you read every framework after. Which part of tiny AWS was hardest, networking or isolation?

Networking. It still is. Still struggling in parts like - giving agents inside the sandbox a network to make web requests.

this matters more post-ai than it did before: generation got cheap and verification didn't. you can't tell whether 10k lines of go and rust are right unless you've built the tcp stack once. whoever reviews is the ceiling on what the fleet can ship.

Road map to that

一万行就能搭个迷你云，不靠Docker这点有意思，拿来学原理挺合适

Now that sounds some engineering rather than just learning syntax for another framework

Control plane in 10k lines is plausible; the bill lands on the data plane. Without VMs or containers, multi-tenant isolation, EBS-style durability, and VPC networking are where the real LOC and ops cost live.

no docker and no vms, so what isolates the instances, namespaces and cgroups by hand?

bangerr 🐐

Will it lead to different types of program development ideas? What are you learning the processing logic for exactly? Is it to apply to your everyday life? Is it to generate new types of product thinking? Is it to create more security to your own personal compute and online presence? It looks interesting but unsure of its roi in terms of income generation. Am I looking at this the wrong way? I mean, is everyone going to be programmers in the future and this is the beginning of entry knowledge prerequisites? Few questions you got me asking myself.

I mean can't Opus 5.5 do these things that you mentioned in whatever depth or scale that you're mentioning and think about these questions when building?

The best advice 🗿

curious what the 10,000 lines of golang and rust split into. which part ended up needing rust, and which part stayed in go? that split would say a lot about where the underneath actually is.

Could not agree more.

Good work! One thing I wanted to point out (which I didn't see explicitly mentioned) is that containers use cgroups and namespaces for isolation. However, in cloud environments, this is kernel-based isolation, which has security and multi-tenancy implications.

good work 🔥🔥🔥. keep it up

On it ✌️

i’m writing an http server for this reason. after this is I want to do a mini shell and then a database of some form

You deserve millions of follows mate.

+1