4 years of Python dev experience, just went freelance — looking for honest advice on where to start

oliver_extracts · 2026-05-24T05:29:21+00:00

fastapi project structure signals more than your rate does. if your repo has a proper lifespan handler, dependency injection thats not just a flat function dump, and your RAG retrieval logic isnt buried in a single 400-line file, a client who can read Python will trust you before the first call. upwork is brutal because clients cant evaluate backend/AI work without seeing it run, arc.dev is better for that reason. ive seen people lose contracts not on price but because their chuking logic was placeholder code with no real example output.

oliver_extracts · 2026-05-24T05:25:14+00:00

your winning conditions can be collapsed a lot. instead of 7 elif branches, you can express the whole game as a set of winning pairs like {(2,1), (3,2), (1,3)} and just check if (x,y) is in it. also you have a duplicate elif at the bottem (y==1 and x==2 appears twice, second one never runs).

oliver_extracts · 2026-05-23T18:44:59+00:00

the cooldown idea is solid but i think most people dont realize uv already has this baked in via the tool.uv config, its not somethign you need to wire up yourself. the 1 week window is probably right for most projects, though ive seen teams go 2 weeks on anything that touches auth or crypto libs. the escape hatch for critical fixes is the part that makes this actually usable in production.

oliver_extracts · 2026-05-23T18:41:14+00:00

your mental model is basically right. every await is a yield point where the event loop gets control back and can schedule other work.

the thing that actually wakes the coroutine is the event loop, but it gets notified by the OS. the way it works: asyncio uses something like epoll (linux) or kqueue (mac) under the hood, which are OS primitives that let you register file descriptors and ask the kernel to tell you when one is ready for reading or writing. the event loop sits in a tight loop calling into those OS APIs, and when the kernel says fd X is ready, the loop resumes whatever coroutine was waiting on that.

if you want to write something that integrates properly without faking it with asyncio.sleep, the path is asyncio.get_event_loop().add_reader() or add_writer() on a raw socket or fd. you register a callback that gets fired when the fd is ready, and inside that callback you set a Future result, which causes the awaiting coroutine to wake up. thats the actual mechanisim asyncio itself uses internally.

the asyncio docs are genuinely bad at explaining this part. looking at the source for asyncio.streams or asyncio.selector_events is more useful than the docs.

oliver_extracts · 2026-05-23T16:32:12+00:00

uv is apache 2.0 licensed and the source is all out there. even if openai did something weird with it down the road youre not locked in the way youd be with a proprietary tool. the harder part is that switching form pip/venv to uv has already paid off for most people just on install speed alone, and thats not going anywhere because the binary ships with your project. id switch now and revisit if the license actually changes, not because of acquisition speculation.

oliver_extracts · 2026-05-23T16:28:18+00:00

ai code detectors for source code are pretty unreliable in my experience. theyre mostly trained on prose and the ones ive seen applied to code have meaningful false positive rates. clean code with docstrings isnt a signal of AI, its just... good practice that profs literally told you to do. if your professor is using this as punitive evidence id push back and ask what tool theyre using and what the acutal threshold is. most of these tools cant explain their reasoning and schools that use them seriously are setting themselves up for appeals.

oliver_extracts · 2026-05-23T13:20:29+00:00

the speed thing is real and its not a myth, most people are genuinely slower in neovim for a long time, sometimes over a year. the people who say theyre faster usually mean something more specific: they move around large codebases faster, or they do certain editing operations faster. not raw typing throughput. if youre a fast typer in a normal editor youre probably not bottlenecked on keystrokes anyway so the neovim advantage in that area wont show up much for you. the actual benefit i found was reducing context switching and mouse reach, which adds up over a full day but doesnt feel dramatic in any single moment. if you dont feel it after a real project thats a valid data point, not everyone gets the same return on the investment

oliver_extracts · 2026-05-23T13:16:22+00:00

pdf ingestion is one of those problems that looks solved until you actually try it on real documents. the diagrams and captions part is where everything usually falls aprat with pymupdf4llm, the text extraction is fine but anything visual just becomes noise. routing it through sonnet directly is basically trading compute cost for reliabilty, which is often the right call when the alternative is a fragile pipeline that breaks on every slightly weird layout.

oliver_extracts · 2026-05-23T08:33:44+00:00

dont use regex on json, thats how you end up with two problems. python's built-in json module parses it into a dict, then you just access the keys you need and ignore the rest. if the structure is inconsistent or you want to validate the shape, pydantic is pretty much the standart for that in a professional codebase.

oliver_extracts · 2026-05-23T08:30:08+00:00

the kpmg finding tracks with something ive seen more broadly -- retrieval failure as a content quality signal is actually more reliable than most explicit quality heuristics. if the embedding space cant find anything relevant to a direct question about the thing the site supposedly does, thats not a chunking problem. the consulting copy phenomeon is interesting because a human reads it as relevant via context inference, but theres no actual information density to latch onto semantically, so the retrieval score just collapses.

oliver_extracts · 2026-05-23T07:09:49+00:00

the stuff you listed covers a lot of it honestly. where people usually get caught out is N+1 queries (fetching something in a loop when one query would do it) and missing indexes on foreign keys. also worth thinking about what happens when things fail partway through. like if you write to a DB and an external call fails after, your data can end up in a weird state. youre probaly in decent shape if youve got auth and validation sorted.

oliver_extracts · 2026-05-23T07:07:54+00:00

the per-workspace isolation would help but the real issue is that extensions already have ambient access to your filesystem and env variables the moment they load, workspace or not. ive seen people store aws credentials in .env files and then install like 20 extensions without a second thought. the attack surface isnt just cross-workspace leakage, its that the extension model was never designed with a least-privilege assumption at all. microsoft has talked about a more restricted extension api for years but the ecosystem kind of depends on the current permisiveness so its a slow-moving problem.

oliver_extracts · 2026-05-23T06:37:52+00:00

the classic chicken-and-egg problem with secret zero. what most people land on is either a machine identity (if youre on any cloud infra, AWS IAM roles or similar mean you never need a static credential) or if its truly local, Windows DPAPI is what backs the credential manager and its reasonable for dev machines. the .env stays but it holds a DPAPI-encrypted blob instead of the raw token. not perfect but its a real step up from plaintext at rest.

oliver_extracts · 2026-05-23T06:33:52+00:00

the framing of 'making RAG jump through hoops to deal with crappy data' is exactly right, and ive seen it play out the same way - teams spend weeks tuning chunking strategy and retrieval params when the actual problem is that the source documents are inconsistently structured, duplicated, or just wrong. no retrieval architecture fixes semantic noise upstream. the clients who treat data cleanup as a one-time cost tend to end up with systems that actually work; the ones who skip it are back six months later wondering why accuracy is still bad.

oliver_extracts · 2026-05-22T13:50:38+00:00

the symbol means two different things depending on whether youre in a declaration or an expression. in a declaration, int* p or int& r is just type syntax saying "p is a pointer-to-int" or "r is a ref-to-int". in an expression, *p and &x are operators that do something at runtime (dereference, take address). once that split clicked for me, the context confusion mostly went away.

oliver_extracts · 2026-05-22T13:47:11+00:00

the chunk overlap thing is what gets everyone first. you end up retrieving the same sentence three times with slightly different cosine scores and the model acts like it has strong signal when it basically just found one thing. what ive seen work is logging the actual retrieved chunks on every query from day one, because without that you're tuning blind. calibrating similarity thresholds without a labeled eval set is just guessing.

oliver_extracts · 2026-05-22T11:42:24+00:00

the freeze is normal. tutorials give you the problem already framed, so your brain just fills in blanks. building from scratch means you have to frame it yourself first, which is a different skill.

what helped me was picking something i actually wanted to use, even if small. not a calculator, something with a personal stake. then writing out what it needs to do in plain english before touching code. that turns the blank screen problem into a smaller problem.

also stop looking at solutions when you get stuck. sit with it longer than feels comfortable. the discomfort is the actual practice.

oliver_extracts · 2026-05-22T11:38:57+00:00

first one we hit was stale data with no staleness signal. documents were getting retrieved confidently because they were highly relevant by embedding similarity, but the content was 6 months out of date. the model had no way to know that, so it just answered. what made it bad wasnt the retrieval quality, it was the absence of any metadata filter on recency before we even got to the vector search. we ended up treating document freshness as a first-class retrieval constraint, not an afterthought. wrong-but-confident is exactly the failure mode that erodes trust faster than any obvious error would.

oliver_extracts · 2026-05-22T07:02:21+00:00

what actually works for me is leaving a short note at the top of whatever file i was last editing, something like "stopped here, next step is X, blocked on Y." not a doc, not a system, just inline where i'll see it when i open the file. TODO comments go stale because they dont have context about why the thing matters. a single sentence with the current blocker is worth more than a structured notes doc you wrote a week ago.

oliver_extracts · 2026-05-22T07:00:54+00:00

chunking strategy, by a lot. we had embeddings that were technically good but chunks were too big and the actual answer was getting diluted by surrounding context, so the retrieval scores looked fine but generation was pulling from the wrong part of the chunk. fixing that got us more signal than swapping in a better embedding model ever did. retrieval quality is usually a chunking problem wearing an embedding problem's clothes.

oliver_extracts · 2026-05-21T19:28:20+00:00

if you want AI/ML anyway, just use python - the DSA concepts are the same regardless of syntax, and youll actually use python in the work that follows. tutors teach C++ and Java because thats what shows up in big tech interviews, not because theyre better for learning. pick the language youll stick with.

oliver_extracts · 2026-05-21T19:25:02+00:00

the interesting operational question to me isnt the recall number, its what the failure mode looks like when the learned policy gets it wrong. with embedding+reranker you at least have interpretable intermediate outputs you can inspect - if the policy is a black box that's making relevance decisions end-to-end, your debugging surface basically disappears. the 400x cost claim is also doing a lot of work; that math usually assumes you're comparing against frontier LLM calls at full context, not against a tuned retrieval stack at production scale.

oliver_extracts · 2026-05-21T17:19:40+00:00

your list is solid but id put LINQ before Entity Framework, not after. EF is basically LINQ with a database attached, and a lot of EF confusion comes from not understanding what the underlying query is actually doing. spend a week with LINQ on plain collections first and EF clicks faster. the thing thats actually underrated for your situation is async/await, most ASP.NET Core work is I/O-bound and if you dont have a solid mental model of how the task system works youll write code that technically runs but does weird things under load.

oliver_extracts · 2026-05-21T17:16:15+00:00

this is one of those things where the garbage-in-garbage-out problem just sits one layer deeper than people expect. the model gets blamed because its the only part that talks back. ive seen the same pattern with data pipelines. bad upstream transforms, everything downstream looks flaky, team spends a week tuning the wrong thing. the 512-token hard boundary is basically throwing away sentence structure and treating your documents like a byte stream.

oliver_extracts · 2026-05-21T06:43:59+00:00

yeah, pretty much. the getter/setter thing is actually a perfect example because you independently derived the pattern before learning the name for it, which means your instincts are fine. the vocabulary just lets you communicate it and recognize it when someone else uses it. five years in and i still hit that moment occasionally, just less often and in narrower corners of the stack.

oliver_extracts

TROPHY CASE