u/Ok_Wolf7414

2012–16 CSE alumnus here — I feel our college exposes students to a very narrow definition of a “good software career”

I graduated from the college in CSE in 2016, and after being out in the industry for several years, one thing I genuinely feel is that our students aren't exposed enough to the software industry beyond the usual software development + FAANG narrative.

From what I see/hear, many students seem to think that the most desirable outcome is basically becoming a developer at Google, Microsoft or Amazon.

And honestly, I don't entirely blame the students for this.

A lot of this perception is reinforced by the college itself.

Teachers seem to give a disproportionate amount of attention and recognition to alumni working at these companies. At alumni meets, you'll often see faculty members specifically approaching and interacting with alumni from Google/Microsoft/Amazon, almost treating them like VIPs.

Meanwhile, there are many other interesting career paths and companies in the software industry that students barely hear about.

For example, I currently work at one of the major companies in the global open-source software ecosystem. Yet when I attend an alumni event, I don't really see the same level of interest or recognition.

More importantly, many current students don't even seem to know much about enterprise open source, Linux, Kubernetes, OpenShift, etc.

And this is the part I find genuinely concerning.

Linux is literally one of the foundations of modern IT infrastructure. Cloud platforms, servers, containers, networking infrastructure, supercomputing, telecom infrastructure, DevOps, Kubernetes, etc. are deeply connected to the Linux/open-source ecosystem.

Yet a CSE student can graduate without having much exposure to Linux or the broader open-source ecosystem.

Again, I don't think this is the students' fault.

I think colleges have a responsibility to expose students to the entire technology ecosystem, not just a handful of companies.

There is a huge world beyond:

DSA → LeetCode → software developer → FAANG

There are careers in:

- Linux / systems engineering

- Cloud infrastructure

- Kubernetes & containers

- Networking

- Cybersecurity

- DevOps / SRE

- Databases

- Enterprise software

- Open-source development

- Developer tools

- Telecom software

- Distributed systems

- Hardware/software integration

- Research

- AI/ML infrastructure

- Solution Architecture

- Customer Engineering

- Technical Account Management

It's also important to understand that not all impactful technical roles are pure "developer" roles.

Roles like Solution Architect, Customer Engineer, Support Engineer and Technical Account Manager can be extremely technical and require deep understanding of systems, cloud, networking and infrastructure.

And one thing I particularly disagree with is the perception that "support = bad career."

That's simply not true, especially in companies working on critical infrastructure software.

In many strong engineering organizations, support engineers work with complex production environments, debug large-scale issues, interact with enterprise customers and sometimes even contribute to upstream open-source projects.

So support should not automatically be equated with low-value work.

Companies like Red Hat, VMware/Broadcom, Cisco, IBM, Oracle, SAP, NVIDIA, Qualcomm, Intel, Datadog, Cloudflare, etc. are all part of this much larger technology ecosystem.

What I find particularly interesting is that several colleges in Pune and South India seem to have much stronger open-source communities, Linux communities and student developer communities. Consequently, students there appear to have much more awareness of companies and career paths outside the usual FAANG route.

I honestly think our college could do much better here.

Instead of only celebrating alumni based on the brand name of their employer, why not invite alumni from different parts of the technology industry and let students understand what these careers actually look like?

For example:

"What does a career in Linux/Open Source look like?"

"How does Kubernetes actually power modern infrastructure?"

"What does a Solution Architect or Customer Engineer actually do?"

"How do you contribute to open-source projects as a student?"

"What are careers in networking, SRE, cybersecurity and cloud infrastructure?"

"How do companies like Red Hat actually build and sell enterprise software?"

The goal shouldn't be to tell students that FAANG is bad. If someone wants to work at Google/Microsoft/Amazon, absolutely go for it.

The point is simply that students should know that these aren't the only definitions of success in computer science.

I'd genuinely love to see our college develop an actual open-source/Linux community where students can work on projects, contribute to GitHub, participate in upstream communities, attend FOSS events, etc.

There is an entire world of technology that students can discover if someone simply tells them that it exists.

Curious to know what current students/alumni think — do you also feel that the college has historically been too focused on a small set of companies and software-development careers?

----------------+++++++---------------+++++++--------

EDIT / ADDITION: A small beginner's map of the technology industry

Since a few people have asked where to start and what I actually mean by "other career paths", I thought I should add something more practical here.

This is NOT meant to be a complete roadmap for every field. The idea is simply to give you a high-level picture of what exists in the industry. Once something catches your interest, you can explore it much more deeply.

Web / Software Development

This is probably the area most CSE students are already familiar with.

You have things like:

Frontend: HTML, CSS, JavaScript, React, etc.

Backend: Java, Python, Go, Node.js, C++, etc.

Databases: PostgreSQL, MySQL, MongoDB, Redis, etc.

Then you have larger areas like distributed systems, APIs, microservices and application architecture.

Typical roles include Software Engineer, Backend Engineer, Frontend Engineer, Full Stack Developer, etc.

This is a huge field and absolutely a valid career path. My point is simply that it is not the entire software industry.

Linux and Systems

This is one area I think students should understand much better.

Linux is not just "an alternative operating system to Windows". It is one of the fundamental technologies behind modern computing infrastructure.

Linux is heavily used in servers, cloud infrastructure, supercomputers, networking equipment, containers, telecom infrastructure, embedded systems and many other places.

Once you start exploring Linux, you naturally encounter things like:

Operating systems, processes, memory, filesystems, networking, virtualization, containers, system administration, security, etc.

Technologies worth exploring include Linux, Bash, Git, networking fundamentals, containers and eventually things like Kubernetes.

Possible careers include Systems Engineer, Linux Engineer, SRE, Platform Engineer, Infrastructure Engineer, etc.

Cloud and Infrastructure

When you use services from AWS, Azure or Google Cloud, there is an enormous amount of infrastructure underneath those services.

This area involves things like:

Servers, virtualization, storage, networking, containers, Kubernetes, automation, infrastructure as code, monitoring and distributed systems.

Technologies you may eventually encounter include Linux, Docker/containers, Kubernetes, Terraform, Ansible, cloud platforms, CI/CD tools, etc.

Roles include Cloud Engineer, Platform Engineer, Infrastructure Engineer, SRE, Cloud Architect, etc.

DevOps / SRE / Platform Engineering

These terms are often thrown around without people actually understanding what they mean.

Very broadly, these areas are concerned with how software gets built, deployed, operated and maintained reliably at scale.

You may deal with:

CI/CD, containers, Kubernetes, monitoring, logging, automation, infrastructure, reliability, incident management and performance.

If you enjoy understanding how large systems actually run rather than just writing application code, this can be a very interesting area.

Networking

This is another area that many CSE students don't explore enough.

Start with the fundamentals:

IP addresses, TCP/UDP, DNS, HTTP, routing, switching, firewalls, load balancing, etc.

Then you can go much deeper into areas like network automation, data center networking, cloud networking, high-performance networking and telecom networking.

Programming is still useful here, but the core knowledge is different from traditional application development.

Possible roles include Network Engineer, Network Automation Engineer, Cloud Network Engineer, Network Architect, etc.

Cybersecurity

Security is much broader than ethical hacking videos on YouTube.

There are areas such as:

Application security, network security, cloud security, identity and access management, vulnerability research, incident response, security operations, penetration testing, etc.

Depending on the area, you may need knowledge of Linux, networking, programming, operating systems, cryptography and cloud technologies.

There are many different career paths within cybersecurity itself.

Databases and Data Engineering

There is an entire world behind the data that applications store and process.

You can explore:

SQL, relational databases, distributed databases, data warehouses, data pipelines, streaming systems, etc.

You will encounter technologies such as PostgreSQL, MySQL, Kafka, Spark and many others.

Possible roles include Database Engineer, Data Engineer, Data Platform Engineer, etc.

AI / ML

AI/ML is obviously huge right now, but even here there are many different paths.

You can explore:

Machine learning, deep learning, NLP, computer vision, recommendation systems, generative AI, LLMs, MLOps and AI infrastructure.

And again, not everyone working in AI is doing research or training giant models.

There are also roles around deploying models, building ML infrastructure, data pipelines, inference systems and production AI platforms.

Open Source

This is particularly worth mentioning because open source is not simply "free software".

A huge portion of the technology industry is built around open-source projects.

Linux, Kubernetes, Git, Python, PostgreSQL, Firefox and countless other projects have enormous open-source communities around them.

One of the best things about open source for a student is that you can actually see how real software is developed by people across the world.

You don't necessarily need to start by writing complex code.

You can begin by reading documentation, reporting bugs, improving documentation, testing things, fixing small issues and gradually contributing code.

Look for issues labelled "good first issue" or "help wanted".

Enterprise Software

Another area students often don't hear much about is enterprise software.

Companies need software for things like databases, cloud infrastructure, virtualization, networking, cybersecurity, automation, business applications, observability, data management, etc.

The companies building these products may not have the same consumer visibility as Google or Microsoft, but their software can be running inside thousands of companies around the world.

This is a massive part of the technology industry.

Technical careers that are not traditional Software Engineering

This is another important point.

You don't necessarily have to choose between "Software Developer" and "non-technical job".

There are highly technical roles such as:

Solution Architect

Customer Engineer

Support Engineer

Technical Account Manager

Sales Engineer

Field Engineer

Developer Advocate

Site Reliability Engineer

Technical Consultant

These roles can involve architecture, debugging, networking, cloud infrastructure, databases, security, large-scale systems and direct interaction with engineering teams or customers.

So don't automatically assume that a role isn't technical simply because the title doesn't contain "Software Engineer".

So how do you actually figure out what you like?

Don't try to learn all of this at once.

Instead, pick one topic every few weeks and simply explore it.

For example:

"What exactly is Linux?"

"Where is Linux used?"

"What does a Linux engineer actually do?"

"What is Kubernetes?"

"Why does Kubernetes exist?"

"What does an SRE actually do?"

"How does the Internet work?"

"What does a network engineer do?"

"What does a cybersecurity engineer actually work on?"

"What happens when I open a website in my browser?"

"What happens when an application gets deployed to the cloud?"

These questions will naturally lead you to other areas.

And this is where LLMs are incredibly useful today. You can have a conversation with an LLM and keep asking questions until something starts making sense.

For example:

"Explain Kubernetes to me as a CSE student who knows programming but has never worked with infrastructure."

Then:

"Why was Kubernetes needed in the first place?"

"What problems does it solve?"

"What should I learn before Kubernetes?"

"What kind of jobs use Kubernetes?"

"What would a beginner project look like?"

You can keep drilling down until you understand the subject.

Just don't blindly trust the answers. Use official documentation, books, courses and real engineers to verify what you learn.

And finally, don't wait until you know everything before joining a community.

Some beginner-friendly places to explore include GitHub, Fedora, Debian, Kubernetes/CNCF communities, OWASP and various open-source projects.

You can also look for local Linux and FOSS communities, developer meetups, hackathons, conferences and college technical communities.

The objective isn't to immediately become an expert.

The objective is to discover what exists.

Once you know that these different worlds exist, you can start asking a much more useful question:

"Which one of these do I actually enjoy?"

That is something I wish more students got exposed to during college.

Senior here from 2012-16 batch AMA

2012–16 CSE alumnus here — I feel our college exposes students to a very narrow definition of a “good software career”