I’ve spent a lot of time teaching and working with people who don’t consider themselves “technical,” but who live and work right alongside technology every day. What I’ve seen over and over is that you don’t need to be an engineer to get real value from the tools that engineers use. You need the right starting point, a bit of curiosity, and a problem you actually care about solving.
This blog is my attempt to share some of those starting points. Think of it less like a crash course in programming and more like a set of shortcuts, habits, and tools that can make your day-to-day work easier, faster, or more insightful. Whether it’s automating a repetitive task, cleaning up messy spreadsheets, or finding better ways to talk with your technical teammates, there are approachable ways into the tech world.
What follows isn’t meant to make you an expert overnight. It’s meant to give you just enough to get your hands dirty, build confidence, and maybe discover that some of the tools you thought were “out of reach” are actually well within it.
For someone just starting out, platforms like Google Colab, GitHub Codespaces, or Binder are hard to beat. They remove the pain of setting up a programming environment (which is often the first roadblock) and drop you directly into somewhere where you can explore, analyze, type some Python code without fear of it ruining your own computer, or even play with pre-existing notebooks others have shared. It’s often as simple as opening a file, loading it up, and trying it out with your own data.
The key for beginners (and honestly, for everyone) is then to focus on progress on a specific outcome, not perfection. Instead of getting lost in perpetually researching what you should learn, or which tool is better than some other one, notice the little manual tasks you repeat every day and see if you can learn enough to automate just one of them. And make your work visible: if you’re working in a Jupyter notebook, don’t just manipulate numbers—draw, plot, and visualize your data so it feels real to you and others.
Finally, don’t underestimate the power of good content creators. People like Anthony Sottile, Jake Vanderplas, and Andrej Karpathy are producing accessible, high-quality guides that make this space much easier to navigate.
Most useful automations start with annoyance. Maybe you’re drowning in emailed inventory reports and just wish new products could be flagged automatically. Or maybe you’re tired of sorting and transforming transactions in Excel the same way over and over again. These are the kinds of repetitive workflows that Python (or other tools) can simplify in under an hour.
Even without advanced coding skills, you’ve got options which can get you started. Large language models (LLMs) like ChatGPT or Claude are good at many of these problems and can generate code for you to start with. Or if you interact with clicking around in a web browser or across desktop applications, tools like Playwright (for browser automation) and Autohotkey (for desktop tasks) can record your actions and replay them as scripts you then can run in half the time or less.
But automation comes with responsibility. The best safeguard is proportionality: treat your solution with the level of care you’d expect if it failed. If it’s just cleaning up files with no fear of losing data, no problem. But if your workflow touches sensitive customer data or business-critical processes—get an expert involved. Security isn’t an area where anyone, even seasoned developers, can afford to cut corners.
At the heart of modern data work is the DataFrame—a two-dimensional table similar to Excel but far more powerful. Libraries like pandas (and newer implementations like Polars or Spark) make it easy to slice, filter, transform, and combine datasets of arbitrary size, and often with just a few lines of code.
Cleaning messy data is one of the most common and most approachable entry points. Renaming columns, normalizing fields, filling missing values, or even detecting anomalies are all tasks supported by these libraries. Some tools go even further, like ydata-profiling which can automatically generate exploratory visualizations and statistics to help you get a handle on new datasets quickly.
If you need to pull data from a database but aren’t an SQL expert, start with GUI-driven tools like DBeaver or explore Datasette. These let you click around to explore tables, often generating the SQL for you. And if you learn just one SQL skill, make it writing a simple SELECT statement with a JOIN—it opens the door to answering a huge number of practical business questions.
AI coding assistants are most effective when you already have a sense of what “right” looks like. Use them on problems where you can spot if the output is off. This isn’t wasted effort—it helps you learn how to ask better questions and refine your prompts, while keeping you in control of the result.
Before trusting AI-generated code in a business setting, keep in mind Simon Willison’s “lethal trifecta”: systems that (1) access private data, (2) communicate externally, and (3) accept untrusted input. If your automation involves even two of those, it should trigger serious caution. AI can be a powerful co-pilot, but it’s not yet a replacement for human review when stakes are high.
Beyond AI, the open-source ecosystem is overflowing with accessible tools. Streamlit and nteract make sharing interactive data analysis easy. Papermill can turn your notebooks into reusable templates. And platforms like Metabase give non-technical teams access to data dashboards without requiring SQL or coding at all.
The biggest challenge isn’t always technical—it’s language. Engineers often need precise requirements, while business teams often want to focus on outcomes. Being explicit about what level the conversation is happening at—are we defining success, deciding what to build, or working out details?—can prevent frustration on both sides.
When communicating with technical teams, clarity is your best tool. If something isn’t working, explain what you did, what happened, and what you expected. Or if you’re trying to improve the user experience of a tool, sit side by side and show off how you use the tool to someone who builds it. Ten minutes of observation can surface more insights than a dozen explicitly written feature requests.
Shared tools also make collaboration stronger. Housing business and technical documentation in a shared knowledge base means anyone can stumble across context that broadens their perspective. Even better, pairing technical and non-technical colleagues for short rotations builds empathy, uncovers workflow improvements, and often sparks creative solutions that wouldn’t emerge otherwise.
The point isn’t to turn everyone into an engineer—it’s to find the tools and tricks that make your own work easier. Maybe that’s cleaning up a spreadsheet faster, automating a small reporting task, or just having enough confidence to ask the right questions in a technical conversation.
The best way to start is small. Pick one everyday annoyance, try a tool, and see if you can make it better. Those little wins add up, and with each one, the technical world feels a little less distant and a lot more accessible.
______
.png)
Julian Berman, VP Client Innovation
.svg)
.png)
.png)
.png)