标签：#beginners

If you've ever built a site for a client, a friend, or your own side project, you've had this conversation: "So... how much would a website cost?" And you've answered with "it depends" — which is true, but useless without context. So here's the breakdown I wish I could just link people to instead of explaining from scratch every time. First: "Website" Is Not One Thing If you've ever built a site for a client, a friend, or your own side project, you've had this conversation: "So... how much would a website cost?" And you've answered with "it depends" — which is true, but useless without context. So here's the breakdown I wish I could just link people to instead of explaining from scratch every time. A landing page and a custom marketplace platform are both "websites" the same way a bicycle and a truck are both "vehicles." Different build process, different skillset, different price tag. Once you separate by type, the numbers actually make sense: Type Typical Range Landing Page / One-Pager $500 – $3,000 Multi-Page Business Site $1,500 – $8,000 E-Commerce Store $2,000 – $20,000+ Custom Web App / Platform $10,000 – $100,000+ The Build-Method Question (This Is the Part Devs Actually Care About) No-code builders (Wix, Squarespace): $15–$50/month. Fast to ship, fine for a hypothesis test. The tradeoff is architectural debt you don't see until you hit it — custom logic, advanced SEO control, and scaling all get harder or impossible without a full platform switch. WordPress / CMS: $50–$500/year for platform + plugins, plus dev time. Flexible, huge plugin ecosystem, no vendor lock-in — but every convenience plugin is also a maintenance and security surface you now own. Custom-coded: starts around $1,000, no real ceiling. This is the only route when requirements exceed what a template or plugin can do — unusual functionality, real performance constraints, or a design that isn't achievable off-the-shelf. The trap: a $20/month builder that gets outgrown in 18 months and rebuilt

Garden Irrigation System Summary MY project to make a bespoke irrigation system for my home garden, which comes in at under £10 per zone including the actual water delivery method, and is made with relatively easily sourced components. I am a mechanical engineer by training, but not an electrician so interested in hearing pointers on how to make it better. Some of the component and tool links below are AliExpress affiliate links. If you buy through them I earn a small commission at no extra cost to you. Everything listed is what I actually bought and used, or the closest equivalent I could find. This helps me fund some more ambitious but hopefully useful builds in the future. Intro So I have a vegetable patch and some flowers in the garden; it became a bit of a job during the hot days of summer to water the plants in the evening. I didn’t especially mind it but given my love of AI and tech, alongside recent experiments with Home Assistant, I thought there must be a 2026 version of this job. I tried a Wi-Fi-controlled tap, but quickly realised the flow rate was low - due to a small aperture size, and also scaling up with this type of solution to 6 + zones would quickly get expensive and leave me dependent on battery-powered solutions - also not a big win. So as I had begun experimenting with creating my own devices with dev boards etc, I figured, “how hard can it be” and in honesty it wasn’t, just took a bit of trial and error. This guide will be focused on how i would build it today, not all the steps that got me to here. My philosophy Standardised equipment/ components as much as possible Speed of delivery = speed of experimentation Modular where possible Anything can be achieved at any cost, but some of the fun is building something from very little Components Note all water pipes for this project are ½ inch and so connector etc are for that, this corresponds to a ¾ in threaded connector for attaching to pipes Standard UK Hose (½ inch) ¾ inch Threaded Tap Push Fit

Most developers treat SEO as "someone else's job" — a marketing concern that happens after the site ships. But a huge chunk of SEO is actually decided at the code level, long before a marketer ever touches the content. If you're building sites — for clients, for yourself, or as side projects — a few technical fundamentals can make or break how discoverable that work ever becomes. Here's the technical SEO checklist I use when reviewing or building sites, from a digital marketing + web perspective. Core Web Vitals Aren't Optional Anymore Google uses three core metrics as direct ranking signals: LCP (Largest Contentful Paint) — how fast the main content loads INP (Interaction to Next Paint) — how responsive the page feels to input CLS (Cumulative Layout Shift) — how visually stable the page is while loading A site can have perfect content and still underperform in search if these numbers are bad. Common culprits: unoptimized images, render-blocking JS, and layout shifts from late-loading ads or fonts. Quick wins: Lazy-load offscreen images Serve modern image formats (WebP/AVIF) Reserve space for dynamic content (ads, embeds) to avoid layout shift Defer non-critical JavaScript Structured Data Is a Developer Task, Not a Marketing One Schema.org markup (JSON-LD is the recommended format) helps search engines — and increasingly AI-driven search summaries — understand what's actually on the page: is this a product, an article, a recipe, an FAQ? Sites with well-implemented structured data are more likely to get rich results (star ratings, FAQ dropdowns, breadcrumbs) in search — which directly impacts click-through rate even without a ranking change. If you're building a site and skip this step, you're leaving visibility on the table for something that's usually a few hours of implementation work. Rendering Strategy Affects Crawlability Client-side rendered (CSR) React/Vue apps can still get indexed, but it's inconsistent and slower than server-rendered or statically generate

Episode 2 | Spring Core | Understanding IoC, Dependency Injection & Beans In Episode 1, I covered the WHY behind Spring — tight coupling, and how Spring takes over creating and providing objects (IoC + DI) instead of classes creating their own dependencies. This episode picks up from there with the parts I hadn't covered yet: how Spring actually does that under the hood — Beans, the Spring Container, and Component Scanning. 🔑 Keywords → 🧠 Understand → 💡 Why? → 💻 Practice → 🎯 Interview Questions → 🛠️ Project 🔑 Keywords for This Episode IoC & Dependency Injection (quick recap) Spring Bean Spring Container / ApplicationContext Component Scanning 1️⃣ Quick Recap: IoC & Dependency Injection From Episode 1: instead of a class creating its own dependency — public class TicketService { private TicketRepository repository ; public TicketService () { repository = new TicketRepository (); } } — Spring creates the dependency and hands it to the class. That's Inversion of Control (IoC) . In code, this usually looks like a constructor parameter: public class TicketService { private final TicketRepository repository ; public TicketService ( TicketRepository repository ) { this . repository = repository ; } } TicketService no longer says "let me create a TicketRepository." It says "I need a TicketRepository" — and Spring supplies one. That act of supplying it is Dependency Injection (DI) . IoC = who's in control of creating/managing objects → Spring. DI = how a class actually receives what it needs → passed in, not self-created. That's the recap. Now — where do these objects Spring creates actually come from, and where do they live? 2️⃣ Spring Bean — what Spring actually manages When Spring creates and manages an object for you, that object is called a Bean . This is the vocabulary you'll see everywhere in Spring code and docs, so it's worth being precise about it. @Service public class TicketService { } The @Service annotation is a signal to Spring: "this class should be managed b

I joined DEV in June and started doing what I have been avoiding for a long time. Now and then, I hit...

Hello! I'm a beginner developer with my sights set on backend development and data modeling. Like a lot of people starting out, I didn't come in with a computer science degree or years of professional experience — just curiosity about how applications actually store, organize, and make sense of data behind the scenes. Backend work has always felt like the "engine room" of software to me. While frontend gets the visual credit, it's the data layer that quietly decides whether an application is fast, reliable, and able to grow. That's what pulled me toward backend and database design in the first place. My biggest challenge so far has been learning SQL and data modeling from scratch. It sounds simple on paper — write some queries, design some tables — but in practice it meant rewiring how I think. I had to move from "how do I make this work right now" to "how do I structure this so it still works when the data grows, the requirements change, or someone else has to read my schema six months from now." Concepts like primary keys, foreign keys, relationships between tables, and eventually normalization weren't hard to memorize, but they were hard to internalize — to actually reach for instinctively when designing something from a blank page. A few things clicked for me along the way: A good schema is a form of communication. Table and column names, relationships, and constraints tell a story about the business logic, not just the data. Getting it "perfectly right" on the first try isn't the goal. Iterating on a design after seeing how data actually flows through it taught me more than any tutorial did. SQL rewards precision. Small differences — a missing JOIN condition, the wrong key, an unindexed column — can quietly break correctness or performance, so being deliberate matters. Constraints are a beginner's best friend. Things like NOT NULL, UNIQUE, and foreign key constraints catch mistakes early instead of letting bad data pile up silently. This foundation in SQL and d

1. Crypto & Security Tools Crucial for authentication setup, payload verification, and security testing. JWT Parser / Decoder: Decodes JSON Web Tokens ( Header , Payload , and Signature ) without transmitting secret keys over the internet. Token & Password Generator: Generates cryptographically secure random passwords and API tokens with customizable character sets, lengths, and complexity rules. Hash Text Generator: Computes cryptographic hashes (MD5, SHA-1, SHA-256, SHA-512) for strings to verify integrity or check signature matching. Bcrypt Hash / Verifier: Hashes plain-text passwords or checks plain text against an existing hash using the bcrypt algorithm. UUID / ULID Generator: Creates universally unique identifiers (v4 UUIDs) or time-sortable lexicographically sortable unique identifiers (ULIDs). BIP39 Mnemonic Generator: Generates seed phrases and cryptographic keys used in wallet initialization and HD key generation. RSA Key Pair Generator: Generates public and private RSA key pairs directly in the browser for local testing of asymmetric encryption systems. Basic Auth Generator: Quickly constructs Authorization: Basic <base64> HTTP header credentials from a username and password. 2. Formatters & Prettifiers (Development) Saves hours when dealing with messy logs, API responses, or raw system configurations. JSON Prettify & Minify: Formats unformatted API JSON strings with customizable indentation or compresses them into a single line to reduce payload sizes. JSON Diff: Highlights additions, deletions, and structural changes between two JSON payloads. SQL Prettify: Formats raw SQL queries into clean, readable multi-line statements with capitalized keywords. YAML / XML Formatter: Cleans up indentation, validates structure, and formats raw XML and YAML files. Docker Run to Docker Compose: Translates single CLI flags ( docker run -d -p 80:80 ... ) into a structured docker-compose.yml file. Cron Expression Generator & Parser: Provides human-readable schedules from

When I first looked at AWS, it felt unnecessarily complicated. EC2 runs something. S3 stores something. RDS manages something. Lambda does something “serverless.” I understood the definitions individually. But I still didn't understand AWS. The breakthrough comes when you stop learning these services separately and ask one simple question: How would I use EC2, S3, RDS and Lambda together to build one real application? That's when AWS starts making sense. So instead of another article explaining AWS services like dictionary definitions, let's build something. Imagine we're creating a simple job portal where users can create accounts, upload resumes and apply for jobs. Nothing extraordinary. But this small application is enough to understand some of the most important ideas in cloud architecture. First, Forget AWS for a Minute Before choosing any AWS service, think about what our application actually needs. Someone visits our website. They create an account. They upload their resume. They browse available jobs. They submit an application. When a resume is uploaded, perhaps we want to automatically process it and extract some basic information. Already, we can identify four different technical problems. We need somewhere to run our application. We need somewhere to store uploaded files. We need somewhere to store structured information such as users and applications. And we need something that can automatically react when certain events happen. Now AWS becomes easier. Because instead of memorizing services, we're matching problems to solutions. Our architecture starts with four pieces: EC2 → Application S3 → Files RDS → Structured Data Lambda → Event-Driven Processing Let's see what that actually means. EC2: Where Our Application Lives Our job portal needs backend code. Maybe we're building it using Python, Node.js, Java or another backend technology. That code needs somewhere to run. This is where Amazon EC2 enters the picture. Think of EC2 as renting a computer insid

Managing library updates can be tedious at times. Learn how the GitHub Copilot app can handle this type of repetitive task. The post GitHub Copilot app for Beginners: Automate Dependabot pull request triage appeared first on The GitHub Blog .

Olá, comunidade dev.to! Meu nome é Neto, tenho 17 anos e sou estudante de Ciência da Computação no UNIPÊ, em João Pessoa. Atualmente, estou cursando o segundo semestre da graduação e também estudando design profissional, área que considero importante para a criação de soluções digitais mais úteis, intuitivas e visualmente agradáveis. Minha trajetória na tecnologia ainda está no começo, mas já tem sido marcada por descobertas, aprendizados e desafios. Escolhi Ciência da Computação porque sempre tive curiosidade sobre como aplicativos, sites e sistemas funcionam. Quero aprender não apenas a programar, mas também a compreender todo o processo de desenvolvimento de um produto, desde a identificação de um problema até a construção de uma solução. Durante o curso, tive a oportunidade de desenvolver, com alguns colegas, um projeto relacionado à criação de um aplicativo. Essa experiência foi importante porque me mostrou que desenvolver um produto vai muito além de escrever código. Foi necessário discutir ideias, organizar tarefas, pensar nas necessidades dos usuários e encontrar soluções para os problemas que surgiram durante o processo. Mesmo enfrentando desafios simples, percebi como cada obstáculo pode contribuir para o nosso crescimento. Em alguns momentos, precisamos revisar decisões, corrigir erros e adaptar o projeto. Também aprendemos que uma equipe precisa manter uma boa comunicação, pois cada integrante possui habilidades, responsabilidades e pontos de vista diferentes. O estudo de design profissional complementa minha formação em computação. Estou aprendendo que uma aplicação não deve apenas funcionar corretamente: ela também precisa oferecer uma boa experiência ao usuário. Elementos como cores, tipografia, organização das informações, acessibilidade e facilidade de navegação influenciam a maneira como as pessoas utilizam um produto. Ainda tenho muito a aprender sobre programação, design e desenvolvimento de projetos. Porém, entendo que a evolução acontece aos po

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is...

Do you know Git? Of course you do! Today, I’ve got a few of my favorite Git commands for...

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback. I knew XOR. Truth tables, bit flips, the whole deal, nothing new there. Then I was reading some article about P2P networking and ran into the phrase "XOR distance" and just kind of stopped. XOR I know. Distance I know. XOR distance ? That's not a thing, that's two things wearing a trenchcoat. So I went and actually learned how it works, and it turns out it's one of those ideas that's simple once it clicks and mildly infuriating right up until it does. So let's do this properly. We're going to talk about bits, buckets, and why your node's "neighbors" have nothing to do with where they physically live. The one-line version XOR distance between two IDs is just: XOR their bits together, read the result as a number. That number is your "distance." Bigger number, farther apart. Smaller number, closer. That's it. That's the tweet. Obviously that's not satisfying, so let's actually build it up. Step 1: what XOR even does XOR (exclusive or) looks at two bits and asks one question: "do you two agree?" A B A XOR B 0 0 0 0 1 1 1 0 1 1 1 0 Same bits, you get 0. Different bits, you get 1. XOR is basically the "spot the difference" operator of computer science. Now take two IDs (in real systems these are 160-bit or 256-bit hashes, but let's use 4 bits so nobody has to squint): A = 1100 B = 1010 ---- 0110 (this is the XOR) Read 0110 as a plain binary number and you get 6. So distance(A, B) = 6. Congrats, you just computed an XOR distance by hand, you can put that on your resume now. Step 2: why we're even allowed to call this a "distance" Math is picky about the word "distance." For something to count as a proper metric, it needs three properties, and XOR happens to nail all three, which honestly feels like a happy accident but isn't. distance(A, A) = 0. An

I started my career as a software developer, Initially a front end developer and then became a full stack developer where success often meant solving difficult technical problems, building reliable systems, and delivering good software. Becoming a co-founder changed that perspective. Suddenly, building a product wasn't just about writing code. It was about understanding the problem deeply, making decisions with incomplete information, taking responsibility for outcomes, building a team, and constantly deciding what not to build. Now, as an Engineering Director at an AI company, I'm learning to balance both sides staying close to technology while thinking about people, product, strategy, and long-term engineering decisions. Honestly, The transition from developer to founder hasn't been a straight line. It's been a continuous process of learning, unlearning, and becoming comfortable with uncertainty. I'm starting this blog to document some of those lessons from building AI products and engineering teams to the technical decisions and challenges that come with growing a technology company. I know I'm just beginning my journey and that I thought I could perhaps share it with my tech community.

You have probably heard this explanation before: An LLM is a brain. An AI agent is a brain with a...

Intro While building a simple A‑share market monitor for my quant lab work, I initially only cared about extracting obvious metrics: last price, total trading volume, and so on. My naive assumption was that pulling raw JSON from an A‑share real‑time market API and rendering it would finish the job. Once I started running short‑term trading simulation workflows, I realized most actionable insight lives inside structured order‑book data. Level‑2 data is far more than a basic price snapshot. It carries granular bid‑ask tiers plus real‑time order change events. Bad parsing logic will desync your local order book from the real exchange state and mislead your trading simulation decisions. Pain points: Regular market data vs Level‑2 data Standard market APIs return lightweight records built for simple UI display. You mostly get last traded price, total volume, and price change. Level‑2 is designed to reconstruct the full order book. It exposes five‑tier bid/ask prices & volumes, trade direction flags, and order‑update events. You can clearly observe shifts between buying pressure and selling pressure. One common gotcha: A‑share real‑time market APIs don’t follow uniform field naming. Some wrap order tiers inside arrays, others split bids and asks into separate top‑level fields. Without standardized parsing logic, order‑book ratio calculations and strength comparisons will produce wrong results. A typical five‑tier order‑book object includes ticker symbol, bid array, ask array, and timestamp. In my workflow I keep bid‑side and ask‑side processing separate: Bid side : extract best‑bid price and volume, aggregate total buy‑side depth Ask side : extract best‑ask price and volume, assess selling pressure Keeping them isolated makes multi‑side calculations cleaner and speeds up debugging. Efficiency note: Don’t compute directly on raw API payloads I never feed unprocessed Level‑2 raw responses straight into indicator calculations. A normalization step is mandatory. Raw unnormali

Networking terms can feel like alphabet soup when you're starting out — Hub, Switch, Router, MAC address, IP address, Subnet Mask — thrown at you all at once, usually with zero real-world context. Here's how I finally made sense of it, using something a lot more familiar: cricket. The Cricket Analogy Imagine a cricket team with three players: a hub , a switch , and a router . All three are part of the same game, but each has a completely different job — one's a batsman, one's a bowler, one's a fielder. Networking devices work the same way: they're all part of one network, but each does something distinct. Hub — The One Who Shouts to Everyone A hub is the simplest of the three. If only two devices need to talk, you don't even need one — but the moment more than two devices are connected, a hub becomes necessary to relay traffic between them. Here's the catch: a hub has no idea who's talking to whom. If Device A wants to send data to Device B, it sends that data to the hub — and since the hub doesn't know which device Device A actually wants to reach, it just broadcasts the data to every single connected device. So a hub's "functionality" is really a lack of intelligence — it doesn't figure out who wants to speak with whom; it just floods the message everywhere and lets the devices sort it out. Switch — The One Who Knows Everyone by Name A switch does the same basic job as a hub — moving data between connected devices — but with one major upgrade: it actually knows who's who. Instead of blindly broadcasting to every device, a switch keeps a table of each connected device's MAC address , so it can send data directly to the right recipient. What Is a MAC Address? Every device that connects to a network — a laptop, phone, router, anything — has a Network Interface Card (NIC) . That NIC comes with a MAC address : a permanent ID burned in by the manufacturer. If your laptop has an Ethernet port, the NIC lives right behind it. If you're connecting over Wi-Fi instead, the NI

What is Git and Github This is a version control system or tool used to track changes by developers. When one installs git it comes with an inbuilt terminal called gitbash Github is a cloud based platform for storing git repositories online. Just sign up for free,verify via email and your account is created. git and github are connected using a SSH KEY. How Git works. We start by installing git on my Pc, after installation check if git is installed by opening a terminal eg powershell on windows and run git --version Stages Git/Github is broken into four simple stages: working directory is where we write code and amend and delete files. Here changes are made but cannot be tracked unless they are instructed to commit. staging phase is an area where files are modified. commit phase is where git takes everything from the staging area and sends it to our local repository. push phase is where the saved commits are sent to a remote repository like GitHub. Creating folders and files on git bash First identify where we want the folder to be located ls is used to list mkdir "name of the folder" (means make directory) cd " name of the folder" (change directory) Readme texts README.md end with .md since they are written using markdown language.Can use echo,touch or nano commands to write a readme file. If i want to know the contents of my readme file we use: cat README.md git config-this is basically telling it my identity git config --user.name"user" git config --user.email "useremail" git init-this command is used to create or initialize a repository in main/master. git init main git status-shows the repository status. This command shows changes and what is happening in git git status git add-stages changes made git add . this means stage all or one can specify what to be added e.g i want to add only a javascript folder git add script.js git commit-commits records that have been staged in the local git repository.Its like getting a snapshot or memory of the file. git commit -

There was a period when I felt like I was making progress as a developer.I was watching tutorials. Taking courses. Learning new concepts. Saving resources. Watching someone build something and thinking, “Okay, I understand this now.” Then I would move on to the next thing. HTML? Done. CSS? I understand it. JavaScript? I know the basics. React? Let me learn that next. And then another tutorial would appear, followed by another course, another roadmap, another thing I felt I needed to know before I could really start building. The problem was that I was learning a lot but building very little. The Information Loop Looking back, I realise I had fallen into a loop. I would learn something → feel like I understood it → move to something else → repeat. It felt productive because I was constantly consuming information. But when it came time to actually build something from scratch, things suddenly became different. Knowing how something works when someone is explaining it to you is not the same as knowing how to use it when you're staring at a blank editor - I found that out. That's where I started seeing the gap. I had knowledge, but I didn't have enough experience applying that knowledge. And experience comes from doing. The Projects I Didn't Finish I also had a few projects I started and abandoned. Some became too frustrating. Some were pushed aside because I thought I needed to learn something else first. And some simply lost momentum. Eventually, I stepped away from coding for a while. Maybe I needed the break. Maybe I needed to get my head in the game. But coming back has given me a different perspective. I don't think my biggest problem was that I didn't know enough. I think I was waiting to know enough before allowing myself to build. And that can become a very dangerous trap for a beginner.Because there is always something else to learn. There will always be another tutorial. Another framework. Another concept. Another developer who seems to know much more than yo

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback. Every serious API will eventually tell you to sit down and be quiet. Hammer GitHub, Stripe, or AWS a little too eagerly and your requests start bouncing back with a polite but firm 429 . I always found that fascinating, so let's build the thing that says no. By the end of this post we'll have designed a rate limiter that actually holds up when you put it in front of real traffic, and I promise to only make a reasonable number of bucket puns along the way. A rate limiter does one job: it decides how many requests a client is allowed to make in a given window of time. It protects your system from getting flattened, and it keeps one greedy user from eating everyone else's lunch. Simple idea. Surprisingly spicy implementation. Let's build it up piece by piece, the way you'd actually reason through it in an interview or a design doc. First, what are we even building? Before writing a single line, let's agree on what "good" looks like. Here's my wishlist: Configurable limits. Something like "100 requests per minute per user." The rules should not be hardcoded, because free users and premium users deserve different amounts of pain. Honest rejections. When someone goes over, we return HTTP 429 Too Many Requests and include helpful headers telling them how many requests they have left and when the window resets. No mystery. Barely-there latency. This check runs on every single request , so it has to be fast. Let's aim for under 3ms at P95. If your rate limiter is slow, congratulations, you built a second bottleneck. Highly available and shared. Multiple servers need to agree on the same counts. More on why that word "shared" is doing a lot of heavy lifting later. Cool. Now let's start naive and let reality punch us in the face a few times. Attempt 1: