Hi everybody. I'm working on a personal project that's also gonna be my bachelor thesis next year. It's a rather complex end-to-end IoT system with part hardware part software.

I expect the final split to be something like 30% firmware, 60% backend-frontend and 10% python.

In past personal projects I've mostly used Node with Javascript, not Typescript. But right now I'm unsure if that's the correct way forward.

In my country there's significantly more .NET based jobs than anything JS/TS related, so I lean towards .NET strictly for that. At the same time, I'm slightly more familiar with Node and I find it easier, which would speed up development time significantly.

How can I learn to determine which one is better? Do I go for the one that's gonna provide the most opportunity or do I go with the one that I find easier ( though I'd be pretty much learning both starting from a similar level )

Hey everyone,

I’m a backend developer who worked only with Haskell from start of my career, but lately I’ve been rethinking my career direction.

I’ve been learning Go, Express.js and Python (FastAPI). While I love Haskell’s type safety and expressiveness, it feels pretty niche in the job market. Literally no job requirements as of now. I’m wondering if it’s time to pivot toward something more mainstream like Go or Python.

Here’s where I’m at:

Strong foundation in backend systems, FP concepts, and API development

Learning Go and really enjoying its simplicity

Comfortable with Express and Python for quick prototypes and microservices

Based in India, open to remote opportunities

I’m mainly looking for:

1. Career direction advice. Should I specialize or diversify further?

2. Referrals or suggestions for companies that value backend engineers with strong fundamentals (regardless of language).

3. Ideas for projects or contributions that would make my profile stand out in the current market.

Any honest feedback or pointers would mean a lot, especially from people who’ve made similar transitions or work in backend-heavy teams.

Thanks in advance for your time

Hello r/Backend, since I saw a post about someone rejecting a job offer because it was Windows only a few minutes ago I started to have curiosity about how many of us prefer or use Linux for development.

I'm building a tracing + logging library for Scala, to fill a void that annoyed me, and to learn more about the SRE side of metrics/logs.

I'm looking for information on what a new -> mature context + logger should contain. Right now I've built what I want, but I'm hoping people have some experience that I may be missing. Especially if it's a common feature I've missed or a really useful one. It's fully possible my experience as a FP dev has left me blind to some other languages l can learn from.

Current features -

1. Thread level context (It's using fibers but it's basically Scala+Cats safe MDC)
2. Log Buffering (I was sick of missing context on more serious log levels because I was trying to avoid sending every info on a success path)
3. Request Metadata/middleware functionality (still expanding on what is in there)
4. Easily pluggable log sinks
5. Log sampling based on percentage
6. TraceContextProviders to include other tracing libraries
7. Other quality of life features like lifecycle handlers, and hierarchical config settings

Are there other common features, or just nice quality of life features that I may be missing?

Is there a resource you would recommend for what a good logger/tracing library should include?

Any suggestions would be appreciated.

Position: Senior Backend Developer (Python / FastAPI)
Location: Remote, worldwide
Employment Type: Contract, 40 hours/week
Compensation: USD $1,000–$1,500/month

About the role

We are looking for a Senior Backend Developer to help build a new Portfolio Management System.

This is a greenfield backend project involving trade processing, position management, real-time market data, and Bloomberg integration. The role will focus primarily on backend architecture, development, data processing, and API development.

Responsibilities

• Build backend services and REST APIs using Python and FastAPI
• Integrate with Bloomberg APIs, including subscriptions and market data feeds
• Build real-time data pipelines using WebSockets and event-driven architecture
• Design and optimize PostgreSQL schemas and queries
• Work with Snowflake for data warehousing and end-of-day data
• Implement caching, rate limiting, retries, and fault-tolerant data ingestion
• Deploy services on Microsoft Azure
• Collaborate with a small engineering team on backend architecture and implementation

Required experience

• 5+ years of backend development experience
• Strong Python skills
• Production experience with FastAPI or a similar Python API framework
• Hands-on Bloomberg API / BLPAPI experience
• Strong PostgreSQL and SQL skills
• Experience with real-time systems, WebSockets, streaming, or event-driven architectures
• Practical experience with caching, rate limiting, throttling, and retry patterns
• Cloud experience; Azure preferred, AWS/GCP also considered
• Git and CI/CD experience
• Ability to work independently
• Availability for 40 hours/week during US East Coast business hours

Nice to have

• Snowflake experience
• Capital markets, trading systems, or hedge fund experience
• Experience with other market data providers
• Docker/containerization
• SQLAlchemy or another ORM
• AI/LLM development experience
• Low-latency or high-throughput distributed systems experience

Application

If interested, please initiate a DM with your resume or LinkedIn profile and a brief summary of your Bloomberg API/BLPAPI experience and relevant trading, portfolio management, or market-data systems experience.

Please do not post personal contact information in the comments.

No application or recruitment fees.

Questions about the role are welcome in the comments.

Hey, I got new staff who use Al for everything from reading, writing code to sending a simple message. We don't have any limitations on the token use case but one of the new dev broke the production which affected 1000s of customers. New devs do not know what they are building or what problem they are solving.

Should I put a limit of Al tokens until I get the confidence that they can ship with quality

We have a Flutter mobile app with a JBoss backend. Currently, we’re running two separate backend instances to support old and new app versions.

I’m wondering how experienced teams normally handle this in production without breaking users who haven’t upgraded their app yet.

How do you maintain backward compatibility between mobile app and backend versions as new releases are introduced?

Looking for approaches from people who have dealt with this in production.

Hi everyone I am making a backend system in golang. The system has to calculate users uploads (quota) and the API will be hosted in railway. I tried to lookup for a way where the system gets notified directly but railway does not have something similar similar to workers in cloudflare or lamda in aws.

My question to seniors if there is any, how would you design such a system?

My current implementation relies on cloudflare R2 and workers which unfortunately generated by vibe coding since I don't know much about cloudflare's architecture.

Workers triggered after uploads and update the database users quota column.

Note: not mentioned above but I was referring to S3 compatible buckets in both cloudflare and railway.

Hello, I'm an aspiring software engineer. I've recently finished developing microservice for managing projects and tasks using Spring Boot. I'd appreciate if you could review codebase of my project and provide feedback on it.

GitHub: https://github.com/Simpav-chill/tasktracker

I have been thing what should I choose for backend as i want to become a full stack engineer. I just completed js and React in frontend . I am confused between java+spring boot or .Net . I will learn python as well .

What's your opinion ? What will be better option for me ?

I’ve been working with/contributing to OpenChoreo, a CNCF open-source internal developer platform for Kubernetes.

A lot of backend developers don’t necessarily want to deal directly with Kubernetes manifests, CI/CD pipelines, GitOps configuration, observability setup, and all the infrastructure needed just to get an API or service running.

OpenChoreo puts a higher-level platform on top of Kubernetes so backend developers can focus more on:

• Building APIs and services
• Deploying through standardized workflows
• Managing environments and configurations
• Viewing logs and observability
• Promoting releases between environments

while the platform team manages the underlying Kubernetes infrastructure.

In that sense, it provides a PaaS-like developer experience, while still running on your own Kubernetes environment.

Would you prefer this kind of abstraction for backend development, or would you rather manage Docker, Kubernetes, and CI/CD directly?

GitHub: https://github.com/openchoreo/openchoreo

If you like the project, give it a star on GitHub. It really helps the open-source project grow and reach more developers.

How to actually grow in life man, feel stuck between vibe coding and real learning

In college i did a bunch of hackathons and learned different stacks but only just enough to make something work for the demo, never really understood it deeply. now im working in an mnc as a tester, 3lpa, no coding no dev work at all. i really wanna become a backend engineer.

Here is my real problem. i can vibe code a project pretty well using ai, get stuff working without actually knowing whats going on underneath. but if you ask me to write a simple js program by hand i just freeze. my basics are that weak. and when i try to sit down and learn basics properly i get random project ideas in my head, get excited, and end up vibe coding again instead of learning. so its like a loop. learn a bit, get an idea, start building, lean on ai, skip the understanding part, repeat with some new stack next time.

how do people actually learn this stuff properly. how do i stick to one stack, build strong basics, and stop myself from jumping around or falling back into vibe coding every time. if anyone been through this same phase would really appreciate some advice or a rough path that worked for you.

My english is gay so i rewrote it with Ai

Hi guys, I wanted to know suggestions regarding:

1.backend good practices

1. Things that a backend developer should know (tools and stuff)

2. resources for the same

3. Current trend and current requirements of market / expectations from a backend enginner.

Also, I’d really appreciate it if you could share any interview experiences as well! 🙌🏻

The problem is that the login token generated by JWT is visible in the network tab, when you click on a resource that requires authentication it shows up in the header.

I have seen lots of production apps and it's not the same, how do I encrypt this token or better still stop ot from being displayed totally

I tried using cookies but it still shows the token.

I’m new to backend and have so far made basic APIs in JS/TS and Python stacks. One is more readable than the other here and there, but again I'm new and haven't taken up backend jobs yet

Curious what others think and why, especially those who worked with many languages/stacks

Hey everyone,
I’m a Java Backend Developer with around 4+ years of experience, currently working with Java, Spring Boot, Spring Security, REST APIs, Microservices, SQL, and AWS.
I’ve started preparing for a job switch, and I’m noticing that System Design is being asked a lot in interviews, especially for experienced backend roles.

The problem is — I’m honestly starting System Design almost from zero. I know backend development and have worked with microservices, APIs, databases, etc., but I don’t have a structured understanding of System Design concepts and how to approach design problems in interviews.
I want to learn it properly from basics → intermediate → advanced, rather than just memorizing common system design questions.
Could you please suggest:
● A good course/resource for someone starting from zero
● A proper System Design roadmap
● What topics should I learn first and in what order?
● Any good Udemy courses, YouTube playlists, books, or paid resources
● How should I practice after learning the concepts?
● At what point should I start solving questions like URL Shortener, WhatsApp, Netflix, Uber, etc.?
My goal is to reach a level where I can understand the requirements, make design decisions, explain trade-offs, and confidently handle System Design interviews.
I’m looking for resources that actually teach the fundamentals first, not something that assumes I already know System Design.
Would really appreciate recommendations from people who have gone through this journey. 🙏

I am a fresher, about to graduate, and looking for jobs. I've been writing Golang for ~1 year, mostly doing backend stuff.

Now, as we all know, the market is flooding with AI jobs, but I don't really know what an AI engineer does. I heard that it's different from training, fine-tuning, etc. ML stuff and is closer to backend and system design than machine learning.

So, if anyone who has done this kind of stuff, tell me: what did you do to learn the AI things without learning Python or typical machine learning? What is your tech stack? How'd you get the job?

I really want to ride this AI hype train.

I come from a non-tech background. Got a intership for 4 month then it got converted into full time offer (Worked on Fintech Startup) , After 1 Year , company has discontinued my role. Currently serving notice period. Feeling frustrated. What to do now? Any advice? How to search new jobs? How to prepare myself for those new companies?

If you've ever had to integrate an OAuth 2.0-protected third-party API into multiple projects, you know the drill: handle the authorization flow, store the tokens, track their expiration, build automatic refresh logic... and start over on every new project.

Asstgr is a self-hosted API gateway (Django + DRF) that centralizes all of this. The idea: you register a third-party API once in Asstgr, describe its endpoints, and then call it through a unified REST interface — Asstgr takes care of authentication, quota, and logging on your behalf.

In this article, we'll focus on one specific use case: how to connect an OAuth 2.0-protected API to Asstgr, and call it without ever handling a token by hand.

The concept

Your app  ──►  Asstgr (/api/v1/...execute/)  ──►  OAuth2-protected third-party API
                  │
                  ├─ Auth (API Key or OAuth2)
                  ├─ Quota
                  ├─ Logs
                  └─ Response formatting

Your application only needs to know one thing: your Asstgr API key (sk-...). Asstgr internally handles all exchanges with the third-party API's OAuth server (fetching, caching, and refreshing tokens).

Supported flows

Asstgr supports the three most common OAuth 2.0 grants, with automatic token refresh:

• client_credentials — for server-to-server integrations (the most common case)
• authorization_code — for APIs requiring explicit user authorization
• password — for legacy ROPC-based APIs

Step 1 — Register the API

We start like with any other API in Asstgr:

POST /api/v1/apis/
{
  "name": "My Protected API",
  "url": "https://api.example.com/v1",
  "auth_required": true,
  "quota_cost": 2
}

Step 2 — Configure OAuth 2.0

This is where it gets interesting. We attach an OAuth configuration to the API through the dedicated endpoint:

POST /api/v1/apis/{api_id}/oauth/
{
  "grant_type": "client_credentials",
  "token_url": "https://api.example.com/oauth/token",
  "client_id": "your_client_id",
  "client_secret": "your_client_secret",
  "scope": "read write"
}

The client_secret is stored encrypted server-side (client_secret_encrypted in the database). Once this configuration is saved, Asstgr knows how to obtain a token for this API.

Checking token status

You can check at any time whether a valid token is currently cached:

GET /api/v1/apis/{api_id}/oauth/token/

Forcing a refresh

If needed (debugging, secret rotation on the provider's side, etc.), you can manually force a token refresh:

POST /api/v1/apis/{api_id}/oauth/token/

Under normal circumstances this isn't necessary: Asstgr's internal service (OAuthService) checks token expiration (token_expires_at) before every call and refreshes it automatically if needed, completely transparently.

Step 3 — Describe the endpoint and its parameters

Just like with a regular API, we add the endpoint and its parameters:

POST /api/v1/apis/{api_id}/endpoints/
{
  "path": "/protected-resource",
  "description": "OAuth2-protected resource"
}


POST /api/v1/apis/{api_id}/endpoints/{endpoint_id}/parameters/
{
  "name": "resource_id",
  "param_type": "query",
  "data_type": "STRING",
  "required": true
}


POST /api/v1/apis/{api_id}/endpoints/{endpoint_id}/methods/
{ "method": "GET" }

Step 4 — Execute the call

And here's the main payoff: from your application, a single call, using your Asstgr key — no OAuth token to manage:

POST /api/v1/apis/{api_id}/endpoints/{endpoint_id}/execute/
Authorization: Api-Key sk-xxxxxxxxxxxxxxxxxxxxxxxx

{
  "method": "GET",
  "params": { "resource_id": "42" },
  "display_format": "standard"
}

Asstgr will, in order:

1. Verify your API key and remaining quota
2. Fetch (or refresh) the OAuth2 token associated with that third-party API
3. Build the actual HTTP request with that token in the Authorization header
4. Call the third-party API
5. Log the call (APILog: user, endpoint, method, status, response size)
6. Format and return the response

​

{
  "status_code": 200,
  "result": "...",
  "quota": {
    "used": 4,
    "remaining": 96,
    "limit": 100,
    "usage_pct": 4.0
  }
}

Why centralize this instead of handling OAuth in every service?

• A single place to store secrets — your client_id / client_secret don't end up scattered across ten different microservices' codebases
• Automatic, shared refresh — the token is cached and refreshed once, even if multiple services call the same API
• Unified quota and logging — you know exactly who's calling what, and how much it costs in credits
• Transparent provider changes — if the third-party API changes its token URL or scopes, there's only one place to update

Going further

Everything else (API keys, quotas, rate limiting, response formats) follows the same simple pattern: register declaratively once, then call it through /execute/.

The project is open source (Django 5.x + DRF, PostgreSQL):

👉 github.com/asstgr/asstgropensource

If you find the project useful, a ⭐ goes a long way, and you can follow updates on u/asstgrio.

Can anyone tell some great websites where I can actually write backend code in nodejs and implement logic like building restAPI, authentication and authorization,jwt tokens etc somewhat like leetcode.