标签：#care

Breaking Into Full-Stack Development Without a CS Degree: What Actually Worked for Me I didn't go through a computer science program. What I have instead is about seven years of shipping production code, learned almost entirely from official documentation, open-source repos, developer communities, and a lot of trial and error on real client work. If you're on that same path and wondering whether it's enough — here's what actually moved the needle for me, and what turned out to be a waste of time. What worked Building things that had to work, not things that looked good on a syllabus. Tutorial projects teach syntax. Client work teaches you what happens when a payment webhook fires twice, or when your "simple" CRUD app suddenly needs to survive 10x the traffic you designed for. The fastest learning happened on real, slightly terrifying production systems — not curated coursework. Reading source code and official docs before reaching for a course. Anyone can follow a video tutorial. Fewer people will sit with Laravel's own documentation, or actually read through a library's source when the docs run out. That habit compounds — you stop being dependent on someone else pre-chewing the material for you, and you get faster at picking up whatever stack a client happens to be using. Writing about what I learned. Technical writing forced me to actually understand things well enough to explain them, not just well enough to copy-paste them into working code. If you can't write a clear paragraph about why you chose NgRx over plain component state, you probably don't understand it as well as you think. Taking freelance and agency work early, even underpriced. Nobody hands a self-taught developer a senior role on day one. What they will do is pay you to fix their bug, or build their MVP, or maintain their legacy app. That's your CS degree — it's just distributed across a dozen small, real engagements instead of four years in one building. What didn't work (or wasn't worth the time)

5:00 PM. Laptop closed. Slack closed. Workday over. Except my brain didn't get the memo. I'm making...

In the professional world—especially in high-stakes tech environments—we are conditioned to believe that career advancement is a direct result of having the right answers. From the moment we step into our first junior role, we feel the pressure to be the "smartest person in the room." We equate confidence with certainty and value with the ability to provide instant solutions. But after years of working with founders, engineering leaders, and product builders, I have discovered a fundamental truth: The most valuable professionals are not the ones with all the answers. They are the ones asking the right questions. The Trap of the "Answer-First" Mindset When you focus solely on providing answers, you inadvertently limit your scope. You become a bottleneck. You are only as capable as your own knowledge base, and you discourage those around you from thinking critically. This "answer-first" culture often leads to: Superficial Solutions: You solve the symptoms, not the root cause, because you didn't take the time to explore the underlying complexity. Stifled Innovation: When leaders provide all the answers, team members stop proposing ideas. They wait for instructions rather than taking ownership. Fragile Trust: People trust those who are curious and transparent about what they don't know far more than those who bluff their way through uncertainty. Shifting to Inquiry-Led Growth Moving from an "answer-first" mindset to an "inquiry-led" mindset is not just a soft skill; it is a tactical advantage. When you shift your focus to understanding the problem, the entire dynamic of your work changes. 1. From Directive to Generative Instead of telling a developer how to implement a feature, ask, "What are the trade-offs of this approach compared to X?" This forces the engineer to think through the architecture, improving their skills while often revealing a better solution you hadn't considered. 2. Building Psychological Safety When you ask, "What am I missing here?" or "What does t

Get ready for a bit of a ramble about looking for a job as a software engineer in 2026. No, it's not about AI changing the definition of software engineering in 2026. But there's obviously some truth in that. It's about product engineering. Specifically, it's about the challenges engineers face when searching for new opportunities because of the massive shift toward product engineering. I should preface what comes next with this: Searching for a software engineering job in 2026 is really hard. Scroll through LinkedIn or any software career blog and you'll see plenty of posts about how the recruitment system is broken, how good engineers are being ghosted, how CVs are being filtered out by AI screening for keywords. These frustrations are valid, but... you know what else is really hard in 2026? Being a software engineering recruiter. Being a software engineering hiring manager. And software engineering is about solving problems. With that said, you can't solve a problem you don't define. So to lay the foundation, I want to address some challenges I've recognised before addressing what can be done about them. The Problem Space First, the thing that's been haunting me for the last 6 months. Impact articulation . I suspect this isn't a problem that's unique to product engineering, but it's certainly one I've faced as a product engineer. Earlier this year, I completed full interview processes with two separate companies. I felt confident about both. The roles were the type of engineering I'm great at: sitting close to users, working through ambiguity and owning product areas end to end. But neither resulted in a job offer. The feedback I received was surprisingly consistent: I demonstrated strong technical execution, methodical problem-solving, clear communication and product judgement, and consistently sought to understand the "why" behind the "how". But also, I struggled to connect my product decisions to business or user outcomes. It was clear that I was a great engin

One of the biggest transitions in a software engineer’s career is moving from “How do I implement this?” to “How should we design this?” As developers, we naturally focus on writing clean code, implementing features, fixing bugs, and improving performance. But as you move toward an architect role, the questions become different: 🔹 Scalability — Will this solution work when the number of users or transactions increases 10x? 🔹 Maintainability — Can another team understand and extend this solution two years from now? 🔹 Security — Are authentication, authorization, data protection, and secrets management considered from the beginning? 🔹 Performance — Where could bottlenecks occur, and how can we identify them before they become production issues? 🔹 Resilience — What happens when a dependent service goes down? 🔹 Integration — How will this solution interact with existing enterprise systems? 🔹 Technology choices — Does the technology solve the actual business problem, or are we choosing it simply because it is popular? 🔹 Trade-offs — What are we gaining, and what are we giving up with each architectural decision? A senior developer asks: “How can I build this feature?” An architect asks: “What is the right solution for the business, technical, operational, and long-term requirements?” The most important lesson I’ve learned is that architecture is not about creating complicated diagrams or using more technologies. Good architecture is about making the right decisions at the right level , understanding trade-offs, and creating solutions that can evolve with the business. And you don't suddenly become an architect because of a designation. You gradually become one by thinking beyond your code. Java #SoftwareArchitecture #SpringBoot #Microservices #SoftwareEngineering #JavaDeveloper #TechnologyLeadership #Architect

Building a Scalable, HIPAA‑Compliant Healthcare Document Processing Pipeline in .NET & Azure Quick Answer A deep dive into architecting a production‑grade Healthcare Document Processing Pipeline—covering AI extraction, FHIR integration, vector search, and compliance at scale. In my experience, the biggest cost is not the AI model, but the orchestration that turns raw scans into audit‑ready FHIR resources. The right mix of services can reduce latency by 30‑50% while keeping the bill below 10% of the raw compute budget. Choose services that expose a BAA and native hybrid search (Azure Cognitive Search) to avoid a second compliance layer. Prioritize deterministic scaling (Container Apps + Aspire) over elastic serverless when real‑time SLAs are tight. Version your embeddings; treat the vector index as a first‑class contract. HIPAA‑Ready High‑Volume Document Ingestion When a health system starts ingesting thousands of paper‑to‑digital documents per day, the naïve “scan‑and‑store” approach quickly becomes a compliance and performance nightmare. The real challenge is to produce HIPAA‑ready, FHIR‑compliant, low‑latency data that can be consumed by downstream clinical decision support or billing systems. Compliance is not a checkbox; it’s a series of audit trails that must survive a 30‑day retention policy and survive a forensic review. In production, the cost of a single PHI exposure can exceed the annual budget of the entire platform. Real‑World Example Consider a mid‑size hospital that receives 25,000 inpatient discharge summaries, 8,000 lab reports, and 12,000 imaging PDFs every month. Each document is a mixture of scanned images, PDFs, and legacy forms. The billing team needs structured diagnoses and procedure codes within 30 seconds to avoid claim denials, while the analytics team wants similarity search for rare disease cases in the last 12 months. The pipeline must: Extract structured entities with ≥95% accuracy. Redact PHI in transit and at rest. Provide audit logs

Engineers who only understand the technology, and never the business it serves, hit a ceiling early. The best ones develop commercial awareness — a real sense of how value is created, funded, and sold. Two days at 21BY72 Season 4, one of Bharat's leading startup summits — eighty-five ventures on the floor and live pitches in front of six hundred investors — was a concentrated lesson in exactly that, and I wrote about it in this reflection . Technology is a means; the business is the point It's easy, as an engineer, to treat the product as the whole world and the commercial side as someone else's problem. Sitting in a room where eighty-five ventures pitched to investors makes the truth obvious: the technology is a means to a business end, and understanding that end makes you a better engineer, not a distracted one. Watching founders pitch — being judged not on how clever the build was but on whether it solved a real problem people would pay for — reframes how you think about your own work. It pushes you to ask "who is this for and why does it matter" before "how do I build it." What the summit floor teaches an engineer Investors buy problems solved, not features built. The pitches that landed were about a real need and a credible path to meeting it — a discipline that improves engineering priorities directly. Commercial context sharpens technical decisions. When you understand the business constraints — cost, speed to market, who the customer actually is — you make better trade-offs in the architecture, not worse ones. Exposure recalibrates ambition. Being around people building real ventures at scale resets your sense of what's possible and what "serious" looks like. The takeaway The most rounded engineers I've come to admire pair technical depth with genuine commercial awareness. Spending two days inside a major startup summit, watching how businesses are pitched, funded, and built, was a deliberate investment in the half of the picture that a pure engineering educ

The AWS Community Builders program opens applications once a year, typically in early January, and closes within about two weeks. That's a narrow window. If you're serious about the 2027 cycle, you have roughly four months from now to build the contribution track record that gets you selected. I wrote my personal story about getting into the program from Cameroon. This post is different. It's a practical, no-fluff guide covering how the program works, what the application actually asks, what reviewers evaluate (based on patterns from people who've been accepted and rejected), and how to prepare starting today. What the AWS Community Builders Program Actually Is AWS Community Builders is a global program that recognizes people who share AWS knowledge publicly. Not AWS employees. Not necessarily experts. Engineers, students, content creators, and community organizers who consistently write, build, speak, or contribute to open source around AWS services. The key word is consistently . This is not a certification you study for. It's recognition of a public track record of helping others learn and build on AWS. The program sits below the AWS Heroes program in AWS's community ladder. Heroes are veterans with years of visible impact. Community Builders is the accessible entry point, and for most engineers reading this, the realistic first target. It's free to apply. Membership runs in yearly cycles with renewal based on continued activity. The Categories (Pick One That Matches Your Work) When you apply, you select a technology category. For 2026 the categories were: AI Engineering : Building generative AI applications with Amazon Bedrock, prompt engineering, RAG, fine-tuning, agents Cloud Operations : Observability and configuration (CloudWatch, Systems Manager, Config, Service Catalog) Containers : ECS, EKS, Fargate, App Runner Data : Databases and analytics (DynamoDB, RDS, S3, OpenSearch, Redshift, Athena) Dev Tools : CI/CD, CDK, build pipelines, Application Composer Fro

Hello world! 👋 I'm Afee Muhammod Wafy , though most people know me simply as Wafy . I am a science student and self-taught web developer from Rangpur, Bangladesh. If you asked me what truly drives my journey, the answer wouldn't just be lines of code or complex syntax—it is pure, relentless curiosity. The Spark of Building Things From a very young age, I was always fascinated by how things work behind the scenes. Moving into science education naturally shaped how I approach problems: breaking down complex ideas, analyzing the core logic, and finding structured ways to solve them. When I first encountered programming, it felt like having an infinite canvas. I code not because it is an academic requirement or a routine chore, but because there is genuine joy in turning an abstract thought into something functional, accessible, and meaningful to real users. Consistency Over Perfection My learning philosophy is straightforward: stay consistent, stay humble, and never stop exploring . Every bug encountered, every new tool tested, and every experiment with full-stack development, modern APIs, or emerging AI technologies is a stepping stone. I believe true growth comes from getting your hands dirty with real-world problem-solving rather than just absorbing passive tutorials. Why This Journal Exists I started this dev.to journal to document my evolution as a developer in raw, unfiltered detail. Here, I'll be sharing: Real reflections on navigating self-directed learning alongside formal science studies. Honest lessons learned from debugging and architecting digital products. Perspectives on the ever-evolving tech landscape, open-source culture, and developer workflows. Let's Connect The tech community thrives on collaboration and shared knowledge. Whether you're a fellow student balancing studies with code, a seasoned developer, or someone who loves building things—I'd love to hear your story. Portfolio: amwafy.xyz GitHub: github.com/afeemuhammodwafy1 LinkedIn: linkedin.com

Contractor rates are falling, contract durations are shrinking, and the freelance labor market is flooding with senior talent — and the problem isn't the market, it's that contractors keep letting companies define the terms. A senior backend engineer — eight years of production experience, solid Go and Kubernetes chops, three reference clients — recently told a recruiter she was looking for £650 a day. The recruiter called back two days later to say the client had found someone at £450. The counter-offer was presented as good news. That's the state of independent tech work right now. Not a crisis, not a correction — something more mundane and more insidious: a slow, structural re-anchoring of what contractor labor is worth, driven less by any single market force than by the compound effect of layoff volumes, budget caution, and platform-mediated price visibility. Rates are going down. Engagements are getting shorter. And the freelancers accepting this are — not entirely without blame — helping it stick. Here's the uncomfortable claim: the ongoing compression of tech contractor rates is as much a self-inflicted wound as a market inevitability. The conditions that caused it are real. But the capitulation that maintains it is a choice. How We Got Here: The Supply Side Exploded The overrecruitment of 2021 and 2022 didn't just hurt the permanent hiring market when the hangover hit. Software developer jobs saw the biggest boom and bust in vacancies of any sector. No other segment saw hiring more than double in 2022, and hiring has since fallen faster in software development than anywhere else. The engineers who got caught in that bust didn't all disappear. Many turned to contracting. More than 100,000 people were laid off in the technology industry in 2024 alone, and at least some of them are not heading back into exclusively full-time work. LinkedIn's Services Marketplace, launched in 2021 to catch exactly this cohort, saw 10 million people create pages on the platform,

Over the past year, I've watched a lot of engineering teams go through the same adoption pattern with AI tools. They start using GitHub Copilot or Claude. Productivity goes up. And then someone in a meeting asks the question: "Do we still need as many junior developers?" I think that question reveals exactly the wrong mental model. The teams getting the most value from AI tools aren't the ones who figured out what AI can automate. They're the ones who figured out what AI should automate, and then designed their workflows around that distinction. That sounds like a small difference. It isn't. Most of the debate around AI and junior developers focuses on the wrong question: can AI do what juniors do? In a previous article, I explored why that question leads teams in the wrong direction. In another, I looked at what happens when organizations quietly remove the work juniors need to grow. This article is about what the best teams actually do instead. They don't pick AI over junior developers. They redesign how work flows. The AI and Junior Developers Debate Is Asking the Wrong Question The argument goes like this: AI can generate code, write tests, and produce documentation. Junior developers also generate code, write tests, and produce documentation. Therefore, AI can replace junior developers. This looks logical at the task level. But it misses something important. Junior developers aren't primarily valuable for their output. They're valuable for what they become while producing that output. Every bug they debug, every test they write, every pull request they review is quietly building something that doesn't appear in any sprint metric. You can automate a task. You can't automate the learning that comes from doing it. That's where the replacement narrative breaks down. What AI Is Actually Good At After using AI coding tools seriously for a while, certain patterns become clear. AI is fast and reliable for repetitive, well-defined work: boilerplate, standard implementat

An AI assistant will write you a query in ten seconds, the query will run, and the number that comes back will look completely reasonable. This page gives you the five checks that tell you whether that number is right. They take about two minutes, they need no tools beyond the database you already have, and they catch the four mistakes AI-written SQL actually makes. The order matters. The checks are arranged cheapest first, so the first one costs a single row count and the last one costs a short conversation. Most wrong queries fall to the first two. The short version. A query that runs has only passed a grammar check. The number is right when the rows, the filters and the denominator match the question you asked. The database only takes a query as far as the first gate. Why a query that runs can still be wrong Before the list: what do you think the database actually checks when it accepts a query? Grammar. That is the whole list. Spell a table name wrong and you get an error. Sum the wrong column, join in a way that doubles rows, or filter after grouping when the question needed it before, and you get a clean result set with a wrong number in it. Every mistake on this page is valid SQL. AI assistants add one specific difficulty: their queries are fluent. The aliases are tidy, the formatting is clean, and the shape looks like something a careful person wrote. Fluency reads as correctness, and it is not the same thing. Treat an AI query the way you would treat a first draft from a new colleague: with respect, and with the row counts open. The table the examples run on Everything below runs on one small shop dataset, so every number can be checked by hand. Thirteen orders in July, five customers, and a refunds table where two orders were refunded in two parts. Eleven of the thirteen orders are completed; one is refunded, one is pending. There is also a staff_accounts table listing internal accounts, and it contains one NULL row, because real lookup tables usually do.

Building in public You know the risk before you start. Everyone tells you: do not build something the platform could ship. You build it anyway, because you need it and nobody has it. Then one Tuesday the release notes arrive. What the months actually looked like I want to be precise about the cost, because the cost is the reason the release notes hit the way they did. Two hours of sleep on a normal night — not one heroic week, the normal shape of the last few months. Work during the day, build in the evening, debug until the birds started. Weekends were the good days, because nobody interrupted. What got built in that time: a memory layer for AI coding assistants. It saves what was learned after a fix and reads the relevant parts back before the next task. It runs over MCP, so it works in whatever editor you happen to open. It survives restarts, model upgrades and switching tools. I did not build it as a business idea. I built it because I was tired of explaining my own four servers to an assistant every single morning. The hour the release notes landed Anthropic shipped memory into Claude Code. Not "context improvements", not "a longer window". The word in the release notes was memory — the same word I had been using for months to describe the thing I was building. I read it twice. Then I sat there and did the arithmetic that everybody in that position does: months of evenings, the sleep, the weekends — against one line in someone else's changelog. The thought was not complicated. It was three words long. Who needs mine? If you have never had a platform ship your feature, the closest thing I can describe is finding out the thing you have been carrying uphill was already at the top. Not that it was wrong. That it was unnecessary. I did not open the editor that evening. That is the honest version. I read the docs, I read them again, and I went to bed early for the first time in months, which is a strange way for a bad day to end. Why the fear was rational, not dramat

I founded Krasyn, an outpatient EMR with an AI scribe inside it. Krasyn has run a working outpatient clinic's real patient records since March 2026, so what our scribe drafts ends up in charts that real clinicians sign. This post covers two things we shipped in August: a published benchmark of how faithful those drafts are to the transcript, and Note Check, a tool that reads any scribe's note against its transcript and lists what the transcript does not support. Why a fluent note is the problem A faithful note and a note with one invented blood pressure look the same on the screen, and the clinician who signs it owns every sentence. Published evaluations put ambient-scribe hallucination at about 1 to 3 percent of notes. A March 2026 analysis of 71,173 AI-drafted and finalized note sections found a confirmed edit in 5.8 percent of them. The drafting got automated. The checking did not. I wanted a number for our own scribe that I could defend, with the definitions printed next to it. A benchmark without definitions is marketing. The unit: a clinical assertion We measure at the level of a clinical assertion, one atomic statement about the patient that could be true or false on its own. "Denies fever, chills, and nausea" is three assertions. A measurement and its value are one. Hedging is kept verbatim. Every assertion gets exactly one label against the transcript: Supported: the transcript says it, or it is a faithful paraphrase or clinical translation. Inferred: not stated, but a reasonable clinical inference with a basis in the transcript. Tracked separately because it is the contested category. Unsupported: no basis in the transcript at all. Contradicted: the transcript says the opposite, including a symptom the patient denied, a treatment the clinician declined, or another person's symptom attributed to the patient. Hallucination rate is unsupported plus contradicted over all assertions. Coverage is measured separately against key facts per case, because a note tha

The UK government is facing calls to cancel a sprawling health care contract with Palantir. The region of Greater Manchester insists it can do a better job itself.

Classic Machine Learning Through the Eyes of an SRE — Part 7 Picture a client health metric that has been flat at 2 out of 10 for six months. Ask PCA to compress your client-health data and that metric will contribute almost nothing to the directions PCA decides to keep. Not because PCA is broken. Because PCA treats variance as importance, and a signal that barely moves contributes almost no variance. Reduce the data far enough and the independent information it carried is simply not there anymore. But a CSAT frozen at 2/10 is not noise. It is a crisis nobody is escalating. And after compression, it may no longer be available to anything downstream. That is the bet, and in ops data it is frequently wrong. The critical signals are often the quiet ones. There is a cheaper version of the same failure that catches most people first. PCA measures variance in whatever units your features happen to be in, so a metric ranging from 0 to 10,000 can dominate one ranging from 1 to 5 purely because it is bigger. Standardize before you compress, or your first principal component may just be an elaborate way of saying "ticket count." Same class of bug as unscaled features in K-Means and SVM, and it fails just as quietly. What PCA actually is Third answer-finding strategy in the unsupervised set, using the same shorthand as the last two articles. K-Means SEARCHES: iterate and hope. DBSCAN DEFINES: declare a rule and traverse. PCA SOLVES: an eigendecomposition or SVD gives a direct solution rather than an iterative local search. No convergence to babysit, no restarts, no local optima to escape. Two caveats on the word "direct," both worth knowing. Many libraries will use randomized SVD on large matrices, which is approximate and stochastic. And even with an exact solver, eigenvectors are only defined up to sign, so a component can come back inverted between runs or across implementations. The variance explained is identical either way, which is precisely why nobody notices. Hold ont

The cyberattack at CareCloud resulted in one of the largest reported data breaches in the U.S. healthcare industry this year.

Preparing for a Python developer interview often starts with coding problems. You practice arrays, strings, dictionaries, functions, and algorithms. Then you solve a few more problems and feel like you're ready. But an actual Python developer interview can test much more than whether you can write working code. You may need to explain your decisions, debug an unfamiliar piece of code, discuss Python concepts, or describe how you would approach a real development problem. Here are the areas I'd focus on before an interview. 1.Don't Just Solve Python Problems—Explain Them It's possible to solve a coding problem correctly and still struggle in an interview. Interviewers often want to know: Why did you choose this approach? What is the time complexity? What happens with edge cases? Is there another way to solve it ? How would you improve the solution? Try explaining your solution aloud after solving it. If you can't explain why your code works, you probably don't understand the solution as well as you think. 2. Know Python Beyond the Basics Don't stop at syntax. Review concepts such as: Lists, tuples, sets, and dictionaries Mutable vs immutable objects *args and **kwargs Exception handling Iterators and generators Decorators List comprehensions Context managers Object-oriented programming Memory management You don't need to memorize every Python feature. Focus on understanding concepts well enough to explain when and why you'd use them. 3. Practice Debugging Real developers don't spend all day writing code from scratch. A large part of the job involves understanding existing code and fixing problems. Take a small Python program with a bug and practice: Reproducing the problem. Reading the error carefully. Finding the likely cause. Testing your assumption. Fixing the issue. Explaining why it happened. This is also useful interview practice because debugging reveals how you think when the answer isn't immediately obvious. 4.Be Ready for Real-World Questions Depending on t

Can't believe I spent 2 weeks writing this. Last week, I gave a talk at a Cursor community event...

US healthcare is broken. Under RFK Jr., the research agency working to fix it is, too.