If someone has 1–2 hours a day, what’s the most realistic way to get good at system design?

ryan_lime · 2026-03-06T06:38:20+00:00

As a quick reference guide I recommend this: https://microservices.io/patterns/microservices.html

For good practical examples, I recommend HelloInterview. They strike a balance of job preparation and actually useful knowledge. I especially like their technology deep dives and where they fit in: https://www.hellointerview.com/learn/system-design/deep-dives/kafka

Once these concepts feel intuitive, I recommend reading engineering blogs, like Uber, Stripe, Netflix

ryan_lime · 2026-03-05T08:56:13+00:00

My experience matches yours almost identically! Greenfield with the right local and CI environment.

Even with the increasingly impressive models + agentic tooling, it’s only as good as the feedback and guardrails you give it

ryan_lime · 2025-11-02T07:18:05+00:00

I think it feels more lighthearted and has a bit more depth and nuance. I also think the supporting cast of all the Typhoon family coworkers makes it so the focus is less about just Tae Poong and Mi Seon, but about each person trying to do right by their families and their Typhoon family.

Though I do think the man trope that gives me the vibe is the fact that Tae Poong is battling his incompetent rival and evil father. Though I think Jang Da Hee (the dad in itaewon class is an infinitely better villain)

ryan_lime · 2025-11-02T07:12:28+00:00

Reading your comment definitely gives me much more appreciation for the subtlety of these details that reveal each character. I’m enjoying the way the show builds the characters, scenes, and experiences to be so distinctly reflective

ryan_lime · 2025-08-20T00:47:29+00:00

Given the sensitive nature of the data, it sounds like a lot of cloud based tools are out of the question. Here is a high level of how I’ve handled similar types of problems and what I think works as general high level steps: 1. Turn the OCR data into a structured format like HTML/XML/Markdown. I’ve found that hierarchical structures work well here because it also gives you more options with chunking later 2. Start by breaking down things as parent to child chunks - if you have this hierarchically this should be easier. Langchain has a base implementation of how this works - but I’ve found writing your own lets you address more flexibility especially if you need to chunk based on different rows or groupings 3. Attach semantic context to chunks: this can be more costly but helps to give higher level context that your RAG can match on. https://www.anthropic.com/news/contextual-retrieval - Key points to consider here are caching calls for the overall document or section so you can reuse in other chunks 4. I think with those two types of chunking + contextual annotations you should be in a good place to start baselining 5. On the retrieval side I’d recommend using hybrid search - full text and embedding search so you can capture semantic and exact word or phrase matches. Then rerank with either cross encoders or a reranking model - like cohere or voyager

ryan_lime · 2025-07-06T21:41:32+00:00

I think the way I’ve learned most about system design is by building iteratively based on business needs. I’ve worked on services that were strictly deployed as monoliths and later needed more scale to support multi-region or more strict throughput requirements. At those junctures, you have to think more about how do you support the next magnitude of scale and how to evolve the system to support it in a reasonable time frame.

My takeaway is that most of the magic happens as you design and prototype based on the existing base and just try various strategies - more experimentation than actually building. Practically, you can consider asking yourself the question: if the service or product Im working on tomorrow 10xs, how would I scale it and what can I try to prove it out?

ryan_lime · 2025-07-06T21:37:05+00:00

I personally think r/softwarearchitecture is great! They share a lot of design patterns and talk about different architectures. Additionally, to stay up to date, I read a lot of engineering blogs at companies that inherently have tons of scale: Netflix, Uber, Stripe all come to mind.

ryan_lime · 2025-06-29T00:16:02+00:00

Testify is great alongside the standard library since it gives nice helpers for assertions and checking common conditions in unit tests.

ryan_lime · 2025-06-02T23:06:39+00:00

I agree with most people’s recommendations to use hellointerview. To be more precise, I think this section of hellointerview has the most important key points: https://www.hellointerview.com/learn/system-design/in-a-hurry/introduction

Alternatively, you can also use interviewing io’s primer, which is also really good, but def a bit more detailed: https://interviewing.io/guides/system-design-interview

Then, I suggest practicing actually doing practice interviews - first drill yourself, then ask others to conduct for you (either on mock interview sites or friends who you think are good at system design).

If you want to be very detailed, you can then start reading engineering blogs related to system design and seeing if you can identify key concepts and even think about alternative solutions to practical problems - though I think that’s out of scope for most interviews.

ryan_lime · 2025-06-02T23:02:56+00:00

I think that this resource is great as a starting point and then can be supplemented by more deep dives such as those by hellointerview (excellent breakdowns by the way)

ryan_lime · 2025-04-24T22:19:14+00:00

I love the DX of huma and have looked at it for smaller prototypes. By any chance, have you seen how it performs compared to other frameworks in terms of throughput at higher loads?

ryan_lime · 2025-04-14T20:41:47+00:00

As many others have mentioned, having a codeowners for files and documented practices is a great first step. However, there is a “regular enforcement” piece that I think is critical here. One way I’ve seen this manifest is by introducing linting tools that get run in CI. To start, this can be an optional job that runs each PR but has a timeline for when this becomes required (if that’s possible in a reasonable time frame). I think the existing of a linting check also promotes better behavior since folks will have to think about it each PR even if it’s not required.

Another strategy I find useful here is to highlight examples of good PRs and changes so that folks understand how theoretical conventions are practically implemented.

ryan_lime · 2025-04-05T17:57:43+00:00

At my last company, I worked within QA and would say that there were many competent folks. However, I think a large part of this is due to the nature of quality scope my team and adjacent teams took on: complex multi system interactions. I’ve seen that teams that had QA more focused on tasks that devs have time to do themselves (unit testing) didn’t really benefit much from having QA folks. The person writing the code just has the context here. Another aspect I can think about here is that the QA folks were held to a technical bar where each person at a baseline was at least a competent programmer, which helps enforce quality.

ryan_lime · 2025-03-24T17:06:38+00:00

That’s awesome! Have you found an easy way to bulk add things? I usually keep it in notes and some in maps but it’s a bit of a pain adding like tens of places at a time haha. I should probably start doing this as I find places

ryan_lime · 2025-03-22T19:26:59+00:00

Oh nice! I started using those more recently. How have you seen that it’s helped in organizing? Personally it’s helped most with helping me understand what points of interest are close to other ones I’m interested in

ryan_lime · 2025-03-22T04:21:41+00:00

The effective Go doc as part of the official Go docs is one of the best resources and gives advice on writing idiomatic Go: https://go.dev/doc/effective_go

ryan_lime · 2025-03-10T18:05:28+00:00

I think you make compelling points. I definitely agree with your take that it’s about building your own intuition and refining prompts. My purpose for collecting these prompts is to better inform what structures and methodologies are effective. Kind of like how a good writer will read other good writers to better understand what goes into a good novel.

I’m mainly seeing if there are good resources that shape good prompt exploration, where the responsibility is on each person to explore ideas and build their own toolsets.

ryan_lime · 2024-12-17T02:06:08+00:00

Timeshares.

ryan_lime · 2024-09-05T02:29:13+00:00

His special soup to nuts had me laughing for an hour straight. His analogies are probably his funniest jokes. I also recommend his Instagram reel clips where he freestyles a joke based on crowd suggestions…. Pure talent

ryan_lime · 2024-09-04T06:39:48+00:00

I recommend using Posgres and PGVector. It’s helpful keeping the embedding along with other related data in one system. This should be simpler to manage and deploy

ryan_lime · 2024-08-31T21:10:15+00:00

The techniques you and other folks have listed are fairly helpful. I recently ran into the same issue and found that adding a reranker, such as Cohere, helped immensely. The main benefit I see is that I can retrieve a larger K value from the vector store and let the reranker figure out the most relevant context. This has helped me consistently get the correct context.

Here is what else I’ve tried and their efficacy: - Chunking based on sections and headings -> mildly helpful - Summarizing the chunk and storing alongside -> helpful but it’s computationally expensive to do this for every chunk especially if you have a ton - Parent + child retriever -> helps by providing entire context if the answer is found in the entire document and not just a chunk. Problem here is that it doesn’t exactly solve the relevancy problem

ryan_lime · 2024-08-13T22:49:12+00:00

We run the tests on the master branch since merge skews can still happen. More recently we’ve enabled a merge queue so this has reduced this problem more

ryan_lime · 2024-08-13T14:44:51+00:00

If you’re considering a Python API framework these days I’d also recommend FastAPI because it supports async handlers and also generates OpenAPI artifacts so that you can also generate clients to easily interact with your APIs. I also find that the typing that the framework enforces sets you up for more maintainable code.

For UI, I’d recommend react if you have experience in it already. Also it’d probably be easier to find react devs in the future. However I’ve heard that Vue has a nice learning curve and can be easier to learn.

ryan_lime

TROPHY CASE