<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Delaksan Sritharan on Medium]]></title>
        <description><![CDATA[Stories by Delaksan Sritharan on Medium]]></description>
        <link>https://medium.com/@delaksan?source=rss-e435821985e9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*AJn-kSatGv3MO16f</url>
            <title>Stories by Delaksan Sritharan on Medium</title>
            <link>https://medium.com/@delaksan?source=rss-e435821985e9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 12:51:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@delaksan/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How Netflix Stops You From Recording the Screen]]></title>
            <link>https://medium.com/@delaksan/how-netflix-stops-you-from-recording-the-screen-1df2e471295a?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/1df2e471295a</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[streaming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Sat, 24 Oct 2026 15:08:15 GMT</pubDate>
            <atom:updated>2026-10-24T15:08:15.024Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c8j7x-sL8O6E6MhWFBzdMw.jpeg" /><figcaption>Ever wondered why taking a screenshot on Netflix just gives you a black box? Here is how encryption, hardware DRM, and HDCP work together to protect streaming video.</figcaption></figure><p>Try screenshotting Netflix on your phone and you get a black rectangle. Try screen recording and the video area is black while the audio may be silent or cut out. Plug in an HDMI capture card and you get an error or a blank signal. This isn’t one trick. It’s a chain of protections, and each link covers a gap the previous one leaves open.</p><h3>Step 1: The movie is encrypted before it reaches you</h3><p>Netflix doesn’t send you a plain video file. The video is encrypted on their servers, and what your phone downloads is scrambled data. Having the file isn’t enough. You need the <strong>decryption key</strong>, and the key is not shipped inside the video.</p><p>This is <strong>DRM (Digital Rights Management)</strong>. Netflix uses different DRM systems depending on the device: Google’s <strong>Widevine</strong> on Android and Chrome, Apple’s <strong>FairPlay</strong> on iPhones and Macs, and Microsoft’s <strong>PlayReady</strong> on Windows and many smart TVs.</p><h3>Step 2: Your device has to prove itself before it gets the key</h3><p>When you press play, the app asks Netflix’s license server for the key. The server doesn’t hand it to just anyone. Your device first proves what it is and how secure it is, and the server decides which key to release.</p><p>The server also decides how much quality the key unlocks. If the device is certified at the required level, the server releases the content key with a maximum-resolution cap based on that level. If not, it returns a license that only decrypts the lower-resolution versions.</p><p>That’s why a cheap phone can show a 1080p screen but only play Netflix at low quality.</p><h3>Step 3: The key lives where the operating system can’t reach it</h3><p>Your idea about a key stored in a protected value is the heart of it, with one correction. The key isn’t simply hidden from the OS. It’s handled inside a separate, hardware-isolated area of the chip called a <strong>Trusted Execution Environment (TEE)</strong>.</p><p>Widevine defines security levels based on this:</p><ul><li><strong>L1:</strong> video decryption and processing happen inside the TEE.</li><li><strong>L3:</strong> there is no TEE, so it’s the fallback for old and budget devices.</li></ul><p>On L1, the encrypted video goes into the TEE, gets decrypted there, and travels to the screen through a protected path. Android itself, other apps, and malware never see the decrypted frames or the key. That’s why even a rooted phone can’t simply grab the video from memory. Netflix itself isn’t the one holding the key either. The secure hardware is.</p><p>Resolution depends on this too. On L3, playback is typically limited to 540p. A software-only environment is much easier to attack, so studios won’t license HD or 4K to it.</p><h3>Step 4: Why screenshots and screen recording go black</h3><p>Screen capture tools work by asking the operating system for a copy of what’s on screen. But with protected video, the decoded frames never enter the normal memory the OS composes the screen from. They go through the secure path straight to the display hardware.</p><p>So the capture tool asks for the screen and gets a blank area where the video should be. On Android, apps can also set a flag called FLAG_SECURE that tells the OS to refuse screenshots and recordings of that window. Netflix&#39;s blocking is the DRM pipeline plus these OS-level protections working together.</p><h3>Step 5: HDMI and HDCP close the cable loophole</h3><p>What if you skip the phone and capture the signal on the way to the TV with a capture card? That’s what <strong>HDCP (High-bandwidth Digital Content Protection)</strong> is for.</p><p>HDCP is an encrypted handshake over the cable. The source (phone, streaming box) checks whether the receiving device is an approved display. A TV passes. A typical capture card doesn’t, so the source refuses to send the protected picture or lowers its quality.</p><p>The license server can require HDCP, too. Widevine’s license settings can block playback if the client doesn’t report HDCP at the required version or better. That’s why a plain HDMI adapter can break 4K Netflix. The adapter doesn’t support the HDCP version the license demands.</p><h3>The whole chain at a glance</h3><ol><li>Video is encrypted on Netflix’s servers.</li><li>Your device proves its security level to the license server.</li><li>The key is released and handled inside the TEE, never exposed to the OS.</li><li>Frames are decrypted and sent through a protected path, so screenshots and recordings see black.</li><li>HDCP protects the HDMI cable to your TV.</li></ol><h3>What this doesn’t stop</h3><p>No DRM is perfect, and it’s honest to say so. The <strong>analog hole</strong> is the classic one: point a second camera at the screen. It always works, with poor quality. DRM systems have also been broken before, mostly at the weakest level, which is another reason studios keep the best quality locked to hardware-backed devices. DRM raises the cost and effort of copying. It doesn’t make copying impossible.</p><p>The short version: Netflix sends you a locked movie, a secure chip holds the key, and your phone’s hardware keeps the picture out of reach of the software that would record it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1df2e471295a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Go + Google Sheets: Limit Access to One Spreadsheet]]></title>
            <link>https://medium.com/@delaksan/go-google-sheets-limit-access-to-one-spreadsheet-2ce23b836277?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ce23b836277</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[golang-tutorial]]></category>
            <category><![CDATA[google-sheets]]></category>
            <category><![CDATA[google-cloud-console]]></category>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 08:39:38 GMT</pubDate>
            <atom:updated>2026-10-14T08:39:38.675Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TSxgKm3w27Cs5ULIY4K7Og.jpeg" /><figcaption>Why grant access to all 400 spreadsheets when your code only needs one?</figcaption></figure><p>Most Go tutorials for the Google Sheets API stop at “get a token, read some cells.” They also tend to request a scope that can see every spreadsheet in your account. That’s fine for a throwaway script, and a problem the moment the refresh token lands in a .env file on a shared server.</p><p>This guide takes the narrower route. You’ll create an OAuth client, get a refresh token, and write a small Go program that creates its own spreadsheet and then reads and writes only that file. If the credentials leak, the blast radius is one sheet instead of your whole Drive.</p><h3>Why drive.file beats a Sheets-wide scope</h3><p>The usual quick-start scope for reading is spreadsheets.readonly, which covers every spreadsheet the account can see. The drive.file scope works differently. Google describes it as letting an app <a href="https://developers.google.com/workspace/drive/api/guides/api-specific-auth">create new Drive files, or modify files that you open with the app or that the user shares with it</a>, and recommends non-sensitive scopes like it because they grant per-file access.</p><p>Notice what that implies for our program. If the app creates the spreadsheet, the app can keep working with it. Your other 400 spreadsheets (payroll, anyone?) stay invisible to that token.</p><p>Two trade-offs are worth knowing before you commit:</p><ul><li><strong>Existing sheets are off-limits by default.</strong> A token with drive.file can&#39;t open a spreadsheet it didn&#39;t create unless the user explicitly opens or shares it through the app, for example with the Google Picker.</li><li><strong>Scope choice happens at consent time.</strong> If you later need broader access, you’ll need to run the consent flow again with the new scope.</li></ul><h3>Set up the Google Cloud side</h3><p>You do this once per project, and the console steps are the same whichever language you use.</p><ol><li><strong>Create a project.</strong> In the <a href="https://console.cloud.google.com/">Google Cloud Console</a>, open the project selector in the top-left and choose <strong>New Project</strong>.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*A0QPrrvgG9sUJuzS.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sCi3-CZ95NgIw8dv.png" /></figure><p><strong>2. Configure the OAuth consent screen.</strong> Under <strong>APIs &amp; Services → OAuth consent screen</strong>, fill in the app name and your contact email. Pick <strong>External</strong> if you’re using a regular Gmail account. <strong>Internal</strong> only works for accounts inside a Google Workspace organization. You don’t need to specify a domain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hAgkBxy6bxjTWjSJ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JNYo8KEaCTawjCWG.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qfnd8kQXLmttQlgY.png" /></figure><ol><li><strong>Create the OAuth client.</strong> Under <strong>Credentials</strong>, choose <strong>Create Credentials → OAuth client ID</strong> and select <strong>Web application</strong>. Add https://developers.google.com/oauthplayground as an authorized redirect URI, because we&#39;ll use the OAuth Playground for the token exchange. Save the Client ID and Client Secret.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8C94_oHktAQRC8Wg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mapK22adJLpzd6hQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZwV_WAlzYtXgXK5R.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/0*W93Lk-QzLgS3FQNo.png" /></figure><ol><li><strong>Enable both APIs.</strong> In <strong>Library</strong>, search for <strong>Google Sheets API</strong> and click <strong>Enable</strong>. Then search for <strong>Google Drive API</strong> and enable that too. Our program creates a spreadsheet, which is a Drive file, and the drive.file scope is a Drive scope, so the project needs both switched on. If you skip the Drive API, requests can fail with a 403 saying the Google Drive API &quot;has not been used in project&quot; or is disabled. Skipping either API is a common reason a correctly authenticated request gets rejected.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dHV91iDvDvyLVJsF.png" /></figure><h3>Get a refresh token scoped to drive.file</h3><p>Open the OAuth 2.0 Playground, click the gear icon, and tick <strong>Use your own OAuth credentials</strong>. Paste in the Client ID and Client Secret. In the scope box, enter the scope manually:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HvefRisS-IM_8t8q.png" /></figure><pre>https://www.googleapis.com/auth/drive.file</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/992/0*qPqjZBoItQEDabSD.png" /></figure><p>Click <strong>Authorize APIs</strong>, sign in, approve access, then click <strong>Exchange authorization code for tokens</strong>. Copy the refresh token. The access token will expire within the hour, but the Go client will mint new ones from the refresh token on its own.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sRrtIHnm7jymBatb.jpeg" /></figure><p>One gotcha will bite you a week later. Google’s docs say that for an app with the consent screen set to External and a publishing status of Testing, <a href="https://developers.google.com/health/setup">refresh tokens expire after 7 days</a>. If your program suddenly starts failing with invalid_grant, that&#39;s the first thing to check. For a long-running service, move the app to production status before you rely on the token.</p><h3>Create the spreadsheet from Go</h3><p>Install the two dependencies:</p><pre>go get google.golang.org/api/sheets/v4<br>go get golang.org/x/oauth2</pre><p>The Sheets package documents the pattern we need: for a user token from a three-legged OAuth flow, build an oauth2.Config and pass option.WithTokenSource to sheets.NewService, <a href="https://pkg.go.dev/google.golang.org/api/sheets/v4">as shown in the package docs</a>. Because we already hold a refresh token, we skip the exchange step and hand the config a token that contains only that.</p><pre>package main</pre><pre>import (<br>	&quot;context&quot;<br>	&quot;fmt&quot;<br>	&quot;log&quot;<br>	&quot;os&quot;</pre><pre>	&quot;golang.org/x/oauth2&quot;<br>	&quot;golang.org/x/oauth2/google&quot;<br>	&quot;google.golang.org/api/option&quot;<br>	&quot;google.golang.org/api/sheets/v4&quot;<br>)</pre><pre>const driveFileScope = &quot;https://www.googleapis.com/auth/drive.file&quot;</pre><pre>func newSheetsService(ctx context.Context) (*sheets.Service, error) {<br>	cfg := &amp;oauth2.Config{<br>		ClientID:     os.Getenv(&quot;GOOGLE_CLIENT_ID&quot;),<br>		ClientSecret: os.Getenv(&quot;GOOGLE_CLIENT_SECRET&quot;),<br>		Endpoint:     google.Endpoint,<br>		Scopes:       []string{driveFileScope},<br>	}<br>	token := &amp;oauth2.Token{RefreshToken: os.Getenv(&quot;GOOGLE_REFRESH_TOKEN&quot;)}</pre><pre>	return sheets.NewService(ctx, option.WithTokenSource(cfg.TokenSource(ctx, token)))<br>}</pre><pre>func main() {<br>	ctx := context.Background()</pre><pre>	svc, err := newSheetsService(ctx)<br>	if err != nil {<br>		log.Fatalf(&quot;create sheets service: %v&quot;, err)<br>	}</pre><pre>	created, err := svc.Spreadsheets.Create(&amp;sheets.Spreadsheet{<br>		Properties: &amp;sheets.SpreadsheetProperties{Title: &quot;go-limited-access-demo&quot;},<br>	}).Context(ctx).Do()<br>	if err != nil {<br>		log.Fatalf(&quot;create spreadsheet: %v&quot;, err)<br>	}</pre><pre>	fmt.Println(&quot;Spreadsheet ID:&quot;, created.SpreadsheetId)<br>	fmt.Println(&quot;URL:&quot;, created.SpreadsheetUrl)<br>}</pre><p>Run it with the three environment variables set.</p><p>Save the printed spreadsheet ID. That’s the only file this credential set can see.</p><h3>Write and read values</h3><p>With the ID in hand, writing and reading takes a few lines each. A range without a sheet name refers to the first sheet in the spreadsheet, which saves you from hard-coding a tab name that might differ by locale.</p><pre>func writeAndRead(ctx context.Context, svc *sheets.Service, spreadsheetID string) error {<br>	body := &amp;sheets.ValueRange{<br>		Values: [][]interface{}{<br>			{&quot;name&quot;, &quot;role&quot;},<br>			{&quot;Ada&quot;, &quot;engineer&quot;},<br>		},<br>	}</pre><pre>	_, err := svc.Spreadsheets.Values.<br>		Update(spreadsheetID, &quot;A1:B2&quot;, body).<br>		ValueInputOption(&quot;RAW&quot;).<br>		Context(ctx).<br>		Do()<br>	if err != nil {<br>		return fmt.Errorf(&quot;write values: %w&quot;, err)<br>	}</pre><pre>	resp, err := svc.Spreadsheets.Values.Get(spreadsheetID, &quot;A1:B2&quot;).Context(ctx).Do()<br>	if err != nil {<br>		return fmt.Errorf(&quot;read values: %w&quot;, err)<br>	}<br>	for _, row := range resp.Values {<br>		fmt.Println(row)<br>	}<br>	return nil<br>}</pre><p>RAW stores exactly what you send. If you&#39;d rather have Sheets parse =SUM(A1:A3) as a formula, switch to USER_ENTERED.</p><h3>Prove the restriction works</h3><p>Don’t take the scope on faith. Copy the ID of any spreadsheet you created by hand, point writeAndRead at it, and run the program. You should get a permission or not-found style error from the API, because the token was never granted access to that file. Seeing it fail is the real test that your credentials are as narrow as you think.</p><h3>Before you ship</h3><ul><li><strong>Keep secrets out of source.</strong> Load the client secret and refresh token from environment variables or a secrets manager, never a committed file.</li><li><strong>Pin your expectations on token lifetime.</strong> Testing-mode tokens die after a week, and a revoked or long-unused token fails the same way.</li><li><strong>Handle </strong><strong>invalid_grant explicitly.</strong> Log it clearly and alert, because it means a human has to repeat the consent step.</li><li><strong>Wrap rows in typed structs.</strong> Once the plumbing works, mapping []interface{} into your own types makes downstream code far safer.</li></ul><p>The same client-credential pattern carries over to other Google APIs. Swap the package and the scope, and keep asking whether the narrowest scope will do.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ce23b836277" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Add CodeRabbit AI Review to Your Pull Requests]]></title>
            <link>https://medium.com/@delaksan/how-to-add-coderabbit-ai-review-to-your-pull-requests-b06244b4b8d2?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/b06244b4b8d2</guid>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 06:17:34 GMT</pubDate>
            <atom:updated>2026-10-14T06:17:34.367Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ztoWODjwkl8cWUma9j4iqg.jpeg" /><figcaption>Stop waiting on code reviews. Let CodeRabbit AI review your PRs before a human even looks at the diff! 🐰</figcaption></figure><p>CodeRabbit reviews pull requests the moment they open, so feedback arrives before a human reviewer has looked at the diff. Getting it running takes about five minutes. Getting it to behave the way your team wants takes a small config file and a handful of PR comment commands, and this guide covers all three.</p><h3>Install CodeRabbit on your repository</h3><p>Start at the <a href="https://app.coderabbit.ai/login">CodeRabbit login page</a> and sign in with your GitHub account. Choose the organization you want to install it on, then pick the repositories CodeRabbit can access. You can select specific repos or all of them. Click <strong>Install &amp; Authorize</strong> for a new integration, or <strong>Save</strong> if you’re editing an existing one.</p><p>Expect a permissions prompt. CodeRabbit asks for read and write access to your repository because reviews, issue management, and pull request generation all depend on it.</p><p>CodeRabbit also works with GitLab, Azure DevOps, and Bitbucket. The steps differ per platform, but the @coderabbitai commands later in this guide are the same.</p><h3>Open a pull request and see the first review</h3><p>Push a branch and open a PR against your default branch. After a few moments CodeRabbit responds from the @coderabbitai account. If you didn&#39;t write a PR summary, it adds one, and it attaches a detailed code review as a separate comment.</p><p>You don’t need a config file for this. By default, automatic reviews are on and every eligible PR gets reviewed, but two defaults catch people out: draft PRs are skipped, and only PRs targeting the repository’s default branch are reviewed.</p><h3>Control automatic reviews with .coderabbit.yaml</h3><p>To change those defaults, add a .coderabbit.yaml file to the root of your repository. The reviews.auto_review group governs when reviews run:</p><pre>reviews:<br>  profile: assertive<br>  auto_review:<br>    enabled: true<br>    drafts: false<br>    base_branches:<br>      - develop<br>      - &quot;release/.*&quot;</pre><p>Each base_branches entry is a regex pattern, and the list adds to the default branch rather than replacing it. Set drafts: true if you want reviews on work in progress. The profile setting controls how many comments you get: chill is the quieter option and assertive is more thorough. If your team pushes back on comment volume, start on chill.</p><p>There’s also an opt-in route. Set enabled: false and give description_keyword a string like coderabbit:review, and CodeRabbit will only review PRs whose description contains that exact keyword. The <a href="https://docs.coderabbit.ai/configuration/auto-review">auto-review reference</a> documents each option.</p><p>Once the file is committed, post @coderabbitai configuration on any PR to see the settings CodeRabbit actually resolved, including where each value came from. That&#39;s the fastest way to debug a config that seems to be ignored.</p><h3>The commands you should know</h3><p>Commands are PR comments that start with @coderabbitai. Most go in a comment, but a few belong in the PR description, and that distinction trips people up. The <a href="https://docs.coderabbit.ai/reference/review-commands">full command reference</a> lists everything; these are the ones worth memorizing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5v6QnA1aVrJMSyyIHqCZdQ.png" /></figure><h3>Triggering and steering reviews</h3><p>review and full review are easy to confuse. review only looks at what changed since the last pass, so it&#39;s the right call after you push fixes. full review re-reads the whole PR, which makes sense after a large refactor or when a draft PR moves to open and you want the first complete pass. Both use one PR review from your allowance when they run.</p><p>If you’re pushing a rapid series of commits, pause keeps CodeRabbit from commenting on half-finished work, and resume brings it back when you&#39;re ready. ignore is stronger and has one catch: it only works in the PR description, not in comments.</p><h3>Cleaning up and fixing</h3><p>resolve closes out every CodeRabbit thread at once, so make sure you&#39;ve actually addressed the feedback first. It must be a new top-level comment, because it isn&#39;t supported in inline thread replies.</p><p>autofix goes further and has CodeRabbit implement the fixes itself. Post it as a plain comment to commit to the current branch, or use @coderabbitai autofix stacked pr to get the changes in a separate pull request against your branch. Replying with autofix inside a single review thread limits the fix to that thread&#39;s finding. Autofix stops if the PR has merge conflicts and suggests @coderabbitai resolve merge conflict instead.</p><h3>Generating extras</h3><p>@coderabbitai generate docstrings and @coderabbitai generate unit tests do what they say, but both must be switched on first, under reviews.finishing_touches.docstrings.enabled and reviews.finishing_touches.unit_tests.enabled. Autofix, by contrast, is on by default for paid plans. For failing builds, @coderabbitai fix-ci investigates the failed checks and opens a stacked PR with a fix, or commits directly if you use fix-ci commit. That one requires a Team plan and is available on GitHub and Azure DevOps.</p><h3>Talk back to the review</h3><p>You aren’t limited to commands. Reply directly to any CodeRabbit review comment to ask a question or push back, or tag @coderabbitai in a new review comment on a specific line under the <strong>Files changed</strong> tab. A reply like &quot;explain this code block&quot; or &quot;modularize this function&quot; works as a request for that specific spot.</p><h3>A sensible starting setup</h3><p>Install CodeRabbit on one or two repos first, keep the default chill profile, and add develop to base_branches if that&#39;s where your PRs land. Run @coderabbitai configuration once to confirm the settings took effect. From there, the five commands you&#39;ll use most are review, full review, pause, resume, and resolve. Everything else you can pick up as the need shows up.</p><p>For a hands-on walkthrough with a throwaway repo, CodeRabbit’s own <a href="https://docs.coderabbit.ai/quickstart">quickstart</a> walks through a test PR end to end.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b06244b4b8d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Go Integration with Google Sheets API]]></title>
            <link>https://medium.com/@delaksan/go-integration-with-google-sheets-api-4c2cc0a8691d?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c2cc0a8691d</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[integration]]></category>
            <category><![CDATA[google]]></category>
            <category><![CDATA[google-sheets]]></category>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Mon, 14 Sep 2026 09:23:15 GMT</pubDate>
            <atom:updated>2026-09-14T09:23:15.107Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CEMopDUzmSYzQUwiRMzLzg.png" /><figcaption>Connecting Go to the Google Sheets API, simplified step-by-step. From setting up service account credentials to reading and writing live spreadsheet data.</figcaption></figure><p>Google Sheets is one of the most convenient places to store lightweight, structured data, and Go’s strong standard library plus Google’s official client libraries make it straightforward to read that data programmatically. This guide walks through the full setup: creating a Google Cloud project, configuring OAuth 2.0, enabling the Sheets API, and finally writing a Go program that pulls data from a spreadsheet.</p><p><strong>Prerequisites</strong></p><ul><li>Go 1.20 or later installed (go version to confirm)</li><li>A Google account with access to Google Cloud Console</li><li>A Google Sheet you want to read data from</li></ul><h3>Setting Up the Google Sheets API</h3><p>Before any Go code can talk to Google Sheets, the API needs to be enabled on the Google Cloud side, and an OAuth 2.0 client needs to be configured so your program can authenticate. Let’s walk through it.</p><h3>Step 1 — Create a Google Cloud Project</h3><p>Go to the <a href="https://console.cloud.google.com/">Google Cloud Console</a> and create a new project. Click the project selector in the top-left corner, then <strong>New Project</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4_XaqQjkx4hZ15wBvhxQ2g.png" /><figcaption>Opening the project selector in Google Cloud Console to start a new project.</figcaption></figure><p>Give the project a name and click <strong>Create</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rsIWx3Zl6jmy6Snck0mJ7w.png" /><figcaption>Naming the new Google Cloud project before creation.</figcaption></figure><p>Step 2 — Configure the OAuth Consent Screen</p><p>From the left-hand navigation, open <strong>APIs &amp; Services → OAuth consent screen</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PWzcjIWPM4_pjP2JeAXkxg.png" /><figcaption>Fill the information</figcaption></figure><p>Select <strong>Internal</strong> as the user type, since this restricts API access to accounts within your own Google Workspace organization. The right choice if only your team should be able to use this integration. If you’d rather let any Google account access it, choose <strong>External</strong> instead.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ok58kygiYaCVOLWsK4bkCw.png" /><figcaption>Choosing “Internal” as the user type on the OAuth consent screen so only accounts in your organization can access the API.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZVwFUlNKSGIQa3PTi0QPsg.png" /><figcaption>Add a contact information</figcaption></figure><p>Fill in the required fields app name, support email, developer contact with your own details. You don’t need to specify a domain at this stage.</p><h3>Step 3 — Create OAuth Credentials</h3><p>Navigate to the <strong>Credentials</strong> tab and click <strong>Create Credentials → OAuth client ID</strong>. Since we’re authenticating with OAuth 2.0, this is the credential type we need.</p><p>Choose the application type that matches how you plan to run this. For this guide we’ll select <strong>Web application</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hhaaBPNevNK5baK00ABVYg.png" /><figcaption>Selecting “Web application” as the OAuth client type.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UURPQNH_MqC3lTJGdn1qWg.png" /></figure><p>Give the client a name, and under <strong>Authorized redirect URIs</strong>, add:</p><pre>https://developers.google.com/oauthplayground</pre><p>We’ll use the OAuth 2.0 Playground to perform the initial token exchange, so this redirect URI needs to be registered ahead of time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HgoFEWILTQZe0khFUype6w.png" /><figcaption>Adding the OAuth Playground URL as an authorized redirect URI.</figcaption></figure><p>Once created, Google will display a <strong>Client ID</strong> and <strong>Client Secret</strong>. Save both. You’ll need them for the token exchange and for your Go application’s configuration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*bFLfASDGJfl6THM4gwbHLQ.png" /><figcaption>The generated Client ID and Client Secret after creating the OAuth client.</figcaption></figure><h3>Step 4 — Enable the Google Sheets API</h3><p>From the left-hand navigation, click <strong>Library</strong>, search for <strong>Google Sheets API</strong>, and open it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hnLnGjRULx-rqjgIseyecg.png" /><figcaption>Searching for “Google Sheets API” in the API Library.</figcaption></figure><p>Click <strong>Enable</strong>. Without this step, any request your Go program makes will be rejected regardless of how correctly it’s authenticated.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lXQDZSMH-N649XWzD5Fmug.png" /><figcaption>Enabling the Google Sheets API for the project.</figcaption></figure><p>Obtaining an Access Token and Refresh Token</p><p>With the API enabled and credentials created, the next step is generating a token pair so your Go program can access spreadsheet data on your behalf. We’ll use the <a href="https://developers.google.com/oauthplayground">OAuth 2.0 Playground</a> for this.</p><p>Open the Playground, click the gear icon in the top-right corner, and check <strong>Use your own OAuth credentials</strong>. Paste in the Client ID and Client Secret from Step 3.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aqQ7SnN2-1oB2gMoCNJBjA.png" /><figcaption>Enabling “Use your own OAuth credentials” and entering the Client ID/Secret in the OAuth Playground.</figcaption></figure><p>In the scope selector on the left, find <strong>Google Sheets API v4</strong> and select the relevant scopes (typically https://www.googleapis.com/auth/spreadsheets.readonly for read-only access).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*hrZNDcf6suzVhwR-ufh-CQ.png" /><figcaption>Selecting the Google Sheets API v4 scopes in the OAuth Playground scope list.</figcaption></figure><p>Click <strong>Authorize APIs</strong>, sign in with the Google account that owns (or has access to) the target spreadsheet, and approve the requested scopes.</p><p>Back in the Playground, click <strong>Exchange authorization code for tokens</strong>. This generates both an <strong>Access Token</strong> and a <strong>Refresh Token</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XtOsu0Qtuo5HWlrIKhu5uA.jpeg" /><figcaption>The Access Token and Refresh Token generated after exchanging the authorization code.</figcaption></figure><p>With these two tokens, the Client ID, and the Client Secret in hand, you have everything needed to authenticate a Go application against the Sheets API.</p><h3>Connecting Go to the Sheet</h3><p>With the credentials, tokens, and enabled API in place, the Go side of this integration comes down to using Google’s official Sheets client library (google.golang.org/api/sheets/v4) together with the OAuth2 package (golang.org/x/oauth2).</p><p>The general flow looks like this:</p><ul><li>Build an OAuth2 config using the <strong>Client ID</strong> and <strong>Client Secret</strong> from Step 3, pointing at Google’s OAuth endpoint.</li><li>Attach the <strong>Refresh Token</strong> obtained from the OAuth Playground to that config, so the client library can silently mint new access tokens whenever the current one expires. No manual refresh handling required.</li><li>Use that authenticated client to initialize a Sheets service instance.</li><li>Call the service’s values-retrieval method with your <strong>Spreadsheet ID</strong> (found in the sheet’s URL, between /d/ and /edit) and a cell range in standard A1 notation (e.g. Sheet1!A1:D20) to pull the data back as rows.</li></ul><h3>Wrapping Up</h3><p>At this point you have everything needed to authenticate a Go application against Google’s OAuth 2.0 flow and read live data out of a Google Sheet: a registered Cloud project, an OAuth client, an enabled Sheets API, and a valid access/refresh token pair.</p><p>A few natural next steps from here:</p><ul><li>Load the refresh token from environment variables or a secrets manager instead of hard-coding it</li><li>Request the full read/write scope instead of read-only if your program also needs to write data back to the sheet</li><li>Map the returned rows into typed structs to make downstream processing safer and easier to work with</li></ul><p>The same client-credential pattern extends to other Google Workspace APIs — Drive, Docs, Calendar — so once this OAuth setup is in place, adding another integration is mostly a matter of swapping the package and the scope.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c2cc0a8691d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rate Limiting, Explained: How APIs Decide Enough Is Enough]]></title>
            <link>https://medium.com/@delaksan/rate-limiting-explained-how-apis-decide-enough-is-enough-be19d81e1e31?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/be19d81e1e31</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[rate-limiting]]></category>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Thu, 20 Aug 2026 08:36:01 GMT</pubDate>
            <atom:updated>2026-08-20T08:36:01.241Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1Mf3AltLhxqF9QnRzkrl6g.jpeg" /><figcaption>This infographic, generated by Gemini, explains the concept and mechanisms of API rate limiting, from overloading to specific algorithms like token bucket and fixed window.</figcaption></figure><p>Every API eventually meets a client that sends too many requests. Sometimes it’s a bug: a retry loop with no backoff, hammering an endpoint every 10 milliseconds. Sometimes it’s a legitimate customer whose usage grew faster than anyone planned for. Sometimes it’s an attacker probing for weaknesses. Rate limiting is the mechanism that decides, in real time, which requests get through and which get told to wait.</p><p>It sounds simple. It isn’t. The algorithm you pick changes how your system behaves under burst traffic, how fair it is across users, and how much memory and coordination it costs at scale. Get it wrong and you either let abusive traffic through or throttle legitimate customers during your busiest hour.</p><h3>What Rate Limiting Actually Does</h3><p>At its core, rate limiting restricts how many requests a client, user, or API key can make within a given window of time. Exceed the limit and the server rejects further requests, <a href="https://inventivehq.com/blog/http-status-codes-rate-limiting-throttling">typically with an HTTP 429 Too Many Requests response</a>, until the window resets or enough capacity frees up.</p><p>That single sentence hides a lot of design decisions: What counts as “a client”? Is the window fixed to the clock or does it slide? Does the server reject instantly or queue the request? Does a burst of traffic get smoothed out or dropped outright? Each of the algorithms below answers those questions differently, and the right answer depends on what’s sitting behind your rate limiter.</p><h3>The Core Algorithms</h3><p><strong>Fixed window</strong> is the simplest approach: count requests per calendar interval (say, per minute) and reset the counter when the clock ticks over. It’s cheap and easy to reason about, but it has a well-known flaw. A client can send 80 requests in the last second of one window and another 80 in the first second of the next, slipping 160 requests through in about two seconds even though the stated limit is 100 per minute. This is the <a href="https://algomaster.io/learn/system-design/rate-limiting">boundary burst problem</a>, and it’s why fixed window is rarely the right choice for anything public-facing.</p><p><strong>Sliding window</strong> algorithms fix that by tracking requests against a moving time frame instead of a fixed calendar boundary. A sliding window log records the timestamp of every request and counts how many fall inside the trailing window; it’s accurate but expensive to store at scale. A sliding window counter approximates the same idea by blending two adjacent fixed windows by their overlap, trading a small amount of precision for a much smaller memory footprint.</p><p><strong>Token bucket</strong> is the algorithm most public APIs reach for by default. Picture a bucket that holds a fixed number of tokens, refilled at a steady rate. Every request consumes a token, and once the bucket is empty, requests get rejected until it refills. The appeal is burst tolerance: a client that’s been idle can spend its accumulated tokens quickly, then settle back into the steady average rate. Stripe, GitHub, and AWS API Gateway usage plans <a href="https://spacecomplexity.ai/blog/token-bucket-vs-leaky-bucket">all lean on variations of this model</a> because real-world API traffic is bursty, not smooth, and token bucket accommodates that without abandoning a long-term rate cap.</p><p><strong>Leaky bucket</strong> inverts the metaphor. Requests pour into a queue and drain out at a constant rate, like water leaking from a hole in a bucket. If the queue fills up, new requests get dropped or rejected. Unlike token bucket, leaky bucket doesn’t care how bursty the input is; it enforces the same steady output rate regardless. That makes it the better fit for protecting something downstream that genuinely can’t handle spikes, such as a video transcoding pipeline or a payment processor with a fixed-capacity backend.</p><p>Choosing between them isn’t really a matter of one being “better.” Token bucket answers the question “how much can this client burst before I need to slow it down?” Leaky bucket answers “how do I guarantee the thing behind me never sees more than X requests per second, no matter what?” Sliding window log answers “can I get an exact answer for a security-sensitive, low-volume check?” Most teams end up mixing them: token bucket at the API gateway for per-key fairness, leaky bucket in front of a fragile internal service, sliding window counters at the CDN edge where memory efficiency matters more than perfect precision.</p><h3>Telling the Client What Happened</h3><p>A rate limiter that silently drops requests is a rate limiter that generates support tickets. The convention, <a href="https://inventivehq.com/blog/http-status-codes-rate-limiting-throttling">defined in RFC 6585</a>, is to return 429 Too Many Requests along with a Retry-After header telling the client how many seconds to wait, or an HTTP date to wait until. Don&#39;t reach for 403 Forbidden here: 403 implies a permanent authorization failure, and a client that receives one may reasonably give up retrying instead of backing off and trying again later.</p><p>Most production APIs go further and expose their remaining quota proactively, usually via X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset headers, so well-behaved clients can throttle themselves before ever hitting a wall. There&#39;s an effort to standardize this: the IETF&#39;s draft-ietf-httpapi-ratelimit-headers proposes a consolidated RateLimit and RateLimit-Policy field pair to replace the inconsistent X- prefixed conventions that different vendors invented independently. It&#39;s still an Internet-Draft rather than a published RFC, but <a href="https://dev.to/alexisfranorge/preparing-for-the-ietf-ratelimit-header-standard-in-net-3ebk">adoption is starting</a>. Cloudflare added support for it in September 2025. Until it&#39;s finalized, the X-RateLimit-* convention remains what you&#39;ll see in the wild most often.</p><h3>Where It Gets Hard: Distributed Systems</h3><p>Everything above works cleanly on a single machine holding a counter in memory. Real APIs run behind load balancers with dozens of instances, and that’s where naive implementations fall apart. If each instance tracks its own counters independently, a client can spread requests across instances and blow past the real limit without any single instance seeing a violation.</p><p>The usual fix is to centralize the counters in a fast shared store, typically Redis, and use atomic operations (or a Lua script) to check-and-increment in one round trip, avoiding race conditions between concurrent requests. That introduces its own tradeoff: every request now needs a network round trip to the shared store, adding latency, and if you’re operating across regions you either accept eventual consistency in your counters or pay for cross-region coordination. There’s no version of distributed rate limiting that’s free. You’re always trading off accuracy, latency, and operational complexity, and the right point on that curve depends on whether you’re protecting a public API from abuse or enforcing a hard capacity ceiling on a payment processor.</p><h3>The Practical Takeaway</h3><p>Start with token bucket for anything user-facing and bursty; it’s forgiving of real traffic patterns and it’s what most of the ecosystem already expects. Reach for leaky bucket specifically when something behind your limiter has a hard capacity ceiling it cannot exceed. Use a sliding window counter when you’re operating at a scale where fixed-window boundary bursts are a genuine risk and full request logs are too expensive to keep. And whichever algorithm you choose, tell the client what happened: a 429, a Retry-After header, and ideally a running quota so well-behaved clients never have to guess. The algorithm matters less than most teams assume. The feedback loop you build around it is usually what determines whether rate limiting protects your system or just annoys your users.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be19d81e1e31" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Static vs. Rotating Refresh Tokens: An OAuth Detail That Can Break Your Integration]]></title>
            <link>https://medium.com/@delaksan/static-vs-rotating-refresh-tokens-an-oauth-detail-that-can-break-your-integration-397056c7c31d?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/397056c7c31d</guid>
            <category><![CDATA[integration]]></category>
            <category><![CDATA[refresh-token]]></category>
            <category><![CDATA[oauth2]]></category>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Fri, 07 Aug 2026 14:20:00 GMT</pubDate>
            <atom:updated>2026-08-07T14:39:59.181Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Visualizing the difference between static and rotating refresh tokens in OAuth 2.0. Generated with Gemini." src="https://cdn-images-1.medium.com/max/1024/1*7RJSRndmGSm2KSh3AKwdSA.png" /><figcaption>Visualizing the difference between static and rotating refresh tokens in OAuth 2.0. Generated with Gemini.</figcaption></figure><p>While integrating Salesforce and Google APIs using OAuth 2.0, I noticed that the refresh token was stored as a fixed value in .env. At first, that looked wrong. If access tokens expire and are replaced, shouldn&#39;t refresh tokens eventually do the same?</p><p>The answer is no — and that’s because OAuth standardizes <strong>how</strong> refresh tokens are used, not <strong>how long they live</strong> or <strong>whether they rotate</strong>. Those behaviors are implementation choices made by the authorization server, and getting that assumption wrong can break an otherwise correct integration.</p><h3>Two servers, two tokens</h3><p>Most OAuth explanations focus on the tokens themselves, but an equally important detail is that there are two different servers involved, and each token is intended for a different one.</p><pre>Client<br>   │<br>   │ Access Token<br>   ▼<br>Resource Server<br>(e.g. Google Drive API, Salesforce REST API)</pre><pre>Client<br>   │<br>   │ Refresh Token<br>   ▼<br>Authorization Server<br>(the OAuth token endpoint)</pre><h3>Access token</h3><p>An access token is presented to the <strong>resource server</strong> with every API request. Because it’s transmitted frequently, it has a much larger exposure surface — it may appear in memory, logs, network traffic, or debugging tools. For that reason, OAuth providers intentionally make access tokens short-lived, typically anywhere from a few minutes to an hour.</p><h3>Refresh token</h3><p>A refresh token is never presented to the resource server. Instead, it’s exchanged only with the <strong>authorization server</strong> when the client needs a new access token.</p><p>Because refresh tokens are used far less frequently than access tokens and are exchanged only with the authorization server, providers can safely make them long-lived. They are still highly sensitive credentials — anyone who possesses a valid refresh token can continue obtaining new access tokens until that refresh token is revoked or expires.</p><p>This difference isn’t arbitrary. It’s a deliberate trade-off between credential exposure and credential lifetime.</p><h3>What a refresh request looks like</h3><p>When an access token expires, the client exchanges the refresh token for a new access token by calling the authorization server’s token endpoint.</p><pre>POST /oauth/token<br>Content-Type: application/x-www-form-urlencoded</pre><pre>grant_type=refresh_token<br>refresh_token=1//09ab...<br>client_id=your-client-id<br>client_secret=your-client-secret</pre><p>A successful response might look like this:</p><pre>{<br>  &quot;access_token&quot;: &quot;ya29.a0Af...&quot;,<br>  &quot;expires_in&quot;: 3600,<br>  &quot;refresh_token&quot;: &quot;1//09ab...&quot;<br>}</pre><p>That final field is where everything in this article hinges.</p><p><strong>Is the returned refresh token the same one you sent, or is it a brand-new token?</strong></p><p>The answer depends entirely on the OAuth provider.</p><h3>The part OAuth doesn’t standardize</h3><p>OAuth 2.0 (RFC 6749) defines refresh tokens but deliberately does <strong>not</strong> require refresh token rotation. Whether a refresh token remains valid after use or is replaced with a new one is entirely up to the authorization server.</p><p>This leads to two common implementation models.</p><h3>Static refresh tokens</h3><p>Used by providers such as Google and Salesforce in their default server-side OAuth flows.</p><pre>Refresh Token A<br>        │<br>        ▼<br>Access Token<br>        │<br>        ▼<br>Refresh Token A<br>(same token)</pre><p>The refresh token never changes during normal operation. After the initial OAuth consent flow, you store it once and continue using the same value every time you need a new access token.</p><h3>Rotating refresh tokens</h3><p>Common in security-sensitive APIs and increasingly recommended for public clients.</p><pre>Refresh Token A<br>        │<br>        ▼<br>Access Token<br>        │<br>        ▼<br>Refresh Token B<br>(previous token is invalid)</pre><p>Every successful refresh returns a brand-new refresh token while invalidating the previous one.</p><h3>Why this changes your storage strategy</h3><p>The implementation difference directly affects how your application stores credentials.</p><p>For a provider using static refresh tokens:</p><pre>Store refresh token once<br>        │<br>        ▼<br>Read it whenever an access token expires<br>        │<br>        ▼<br>Never overwrite it</pre><p>For a provider using rotating refresh tokens:</p><pre>Store refresh token<br>        │<br>        ▼<br>Refresh access token<br>        │<br>        ▼<br>Receive new refresh token<br>        │<br>        ▼<br>Overwrite stored token<br>        │<br>        ▼<br>Repeat</pre><p>Missing that write step is one of the easiest ways to break an OAuth integration. Everything works during the first refresh, but the next refresh fails because the application continues sending a refresh token that has already been invalidated.</p><h3>Public clients vs. confidential clients</h3><p>One of the biggest factors influencing whether a provider rotates refresh tokens is the type of OAuth client.</p><pre>Backend Service             SPA / Mobile App<br>       │                           │<br>       ▼                           ▼<br>Confidential Client          Public Client<br>(has client secret)        (cannot safely store one)</pre><p>A backend service integrating with Salesforce or Google typically runs as a <strong>confidential client</strong>. It executes on infrastructure you control and can securely store a client secret alongside the refresh token.</p><p>A browser-based SPA or mobile application is a <strong>public client</strong>. Anyone can inspect the application, making it impossible to reliably protect a client secret.</p><p>Because public clients cannot rely on a client secret as an additional layer of protection, modern OAuth security guidance (RFC 9700) recommends refresh token rotation where appropriate. Rotation limits the impact of a leaked refresh token by reducing how long any individual token remains valid.</p><h3>Why rotate refresh tokens?</h3><p>Refresh token rotation exists to reduce the damage caused by credential theft.</p><pre>Attacker steals refresh token<br>        │<br>        ├── Static model<br>        │      │<br>        │      └── Attacker can continue refreshing<br>        │          indefinitely unless the token is revoked.<br>        │<br>        └── Rotating model<br>               │<br>               ├── Old refresh token becomes invalid.<br>               ├── Reuse can be detected.<br>               └── The authorization server may revoke<br>                   the token family, depending on its implementation.</pre><p>Static refresh tokens have no equivalent reuse detection. If one is compromised, the authorization server cannot distinguish the legitimate client from an attacker solely by observing refresh requests.</p><h3>When does a static refresh token stop working?</h3><p>Even under the static model, refresh tokens are not permanent.</p><p>A provider may invalidate them when:</p><ul><li>The user revokes the application’s access.</li><li>The user changes their password (provider-dependent).</li><li>The token remains unused for an extended period.</li><li>An administrator revokes access through organization security policies.</li><li>Provider-specific issuance limits are exceeded.</li></ul><p>Google has another important behavior worth remembering: a refresh token is typically returned only when offline access is requested (using access_type=offline in the authorization request). Without it, your application may receive only an access token and will require the user to reauthenticate once that token expires.</p><h3>Access token vs. refresh token</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ATmJDLYtWTD3fuwSL4rPeQ.png" /></figure><h3>Where should refresh tokens be stored?</h3><p>For local development, storing refresh tokens in .env is perfectly reasonable.</p><p>In production, however, a refresh token should be treated as a long-lived secret and stored in a dedicated secret management system.</p><pre>Development<br>------------<br>.env</pre><pre>Production<br>------------<br>AWS Secrets Manager<br>Azure Key Vault<br>HashiCorp Vault<br>Kubernetes Secrets</pre><p>If the provider implements refresh token rotation, this storage must also support updates. Every successful refresh may return a replacement refresh token, and your application must persist the new value before discarding the old one.</p><h3>Takeaway</h3><p>One of the biggest misconceptions about OAuth is assuming that refresh tokens behave like longer-lived access tokens.</p><p>They don’t.</p><p>Access tokens are intentionally short-lived because they are presented to resource servers on every request. Refresh tokens have a different purpose, a different lifecycle, and sometimes an entirely different storage strategy.</p><p>OAuth defines the protocol for obtaining new access tokens, but it leaves refresh token lifecycle decisions to the authorization server. Some providers keep refresh tokens static for months or years, while others rotate them every time they are used.</p><p>Before implementing your token persistence logic, check the provider’s documentation for one detail:</p><p><strong>Does the provider issue static refresh tokens or rotating refresh tokens?</strong></p><p>The answer determines whether your application can safely store a single long-lived secret — or whether it must update that secret after every refresh.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=397056c7c31d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why GDPR and PII Were Bigger Than I Expected: Lessons I Learned as a Software Engineering Intern]]></title>
            <link>https://medium.com/@delaksan/why-gdpr-and-pii-were-bigger-than-i-expected-lessons-i-learned-as-a-software-engineering-intern-9bf0eab56e80?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/9bf0eab56e80</guid>
            <category><![CDATA[data-protection]]></category>
            <category><![CDATA[pii]]></category>
            <category><![CDATA[personal-data]]></category>
            <category><![CDATA[gdpr]]></category>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Sat, 25 Jul 2026 15:05:20 GMT</pubDate>
            <atom:updated>2026-07-25T15:05:20.907Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ax7-ZVKoSUXU5sEj5HRHJQ.png" /><figcaption>An illustration, generated with Gemini, visualizing the complex data privacy and security concepts faced by a software engineering intern.</figcaption></figure><p>When I started my software engineering internship, I thought my biggest challenges would be learning new technologies, understanding the codebase, and fixing bugs.</p><p>While those were certainly part of the journey, there was something else I hadn’t given much thought to before joining the industry: <strong>data privacy</strong>.</p><p>Like many students and interns, I had heard terms like <strong>GDPR</strong>, <strong>PII</strong>, and <strong>personal data</strong>, but I never fully understood why they mattered. It wasn’t until I started working on real systems that I realized software engineering isn’t just about building features — it’s also about protecting the people who use them.</p><p>This article is a collection of what I’ve learned so far. I’m still learning every day, so if I misunderstand or misinterpret anything, I’d genuinely appreciate corrections. My goal is simply to share what I’ve learned with other students and interns who may be in the same position I was.</p><h3>What is GDPR?</h3><p>The <strong>General Data Protection Regulation (GDPR)</strong> is a privacy law introduced by the European Union to protect people’s personal information.</p><p>Although it originated in Europe, it affects organizations around the world. If a company processes the personal data of individuals in the EU, GDPR may apply regardless of where that company is located.</p><p>At its core, GDPR is about giving people more control over how their personal information is collected, stored, used, and shared.</p><p>It’s also worth knowing that GDPR isn’t the only privacy law out there — it’s just the one that gets talked about most. Depending on where a company operates or where its users are located, other regulations like the <strong>California Consumer Privacy Act (CCPA)</strong>, Brazil’s <strong>LGPD</strong>, or various sector-specific laws (like HIPAA for health data in the US) may apply too. As an intern, I found it useful to think of GDPR less as “the privacy law” and more as the most well-known example of a broader category of rules that all push in the same direction: give people control over their data.</p><h3>What Counts as Personal Data?</h3><p>One thing that surprised me was how broad the definition of <strong>personal data</strong> actually is.</p><p>Personal data is any information that can identify a person, either directly or indirectly.</p><p>Examples include:</p><ul><li>Name</li><li>Email address</li><li>Phone number</li><li>Home address</li><li>Customer ID</li><li>IP address</li><li>Location data</li><li>Online identifiers</li></ul><p>Even information that doesn’t immediately reveal someone’s identity can still be considered personal data when combined with other information.</p><h3>What Are Special Categories of Personal Data?</h3><p>Some information is considered even more sensitive and receives additional protection under GDPR.</p><p>These special categories include information related to:</p><ul><li>Health</li><li>Biometric data used for identification</li><li>Genetic data</li><li>Religious or philosophical beliefs</li><li>Political opinions</li><li>Trade union membership</li><li>Racial or ethnic origin</li><li>Sexual orientation</li></ul><p>Organizations must be especially careful when processing this type of information.</p><h3>GDPR Principles Every Developer Should Know</h3><p>One of the things I found interesting is that GDPR isn’t just a list of rules. It is built around several principles that influence how software should be designed.</p><p>Some of the principles that stood out to me are:</p><ul><li>Collect only the data you actually need.</li><li>Be transparent about why data is collected.</li><li>Keep information accurate and up to date.</li><li>Don’t store personal data longer than necessary.</li><li>Protect data against unauthorized access.</li><li>Be able to demonstrate compliance.</li></ul><p>As developers, many of these principles influence the systems we build, even if we aren’t making legal decisions ourselves.</p><h3>Lawful Basis for Processing Data</h3><p>Another concept I came across was that organizations cannot simply collect personal data because it might be useful someday.</p><p>There needs to be a lawful reason for processing it, such as:</p><ul><li>User consent</li><li>Fulfilling a contract</li><li>Legal obligations</li><li>Protecting someone’s vital interests</li><li>Public interest</li><li>Legitimate business interests (when appropriate)</li></ul><p>Understanding that there must always be a valid reason changed how I think about collecting user information.</p><p>That last one — “legitimate business interests” — is worth a second look, because it’s easy to misread as a catch-all excuse. It isn’t. This basis only holds up if the company’s interest in processing the data is actually balanced against the individual’s rights and expectations. If collecting or using someone’s data would surprise or harm them, “it was useful to us” generally isn’t good enough. I found it helpful to think of it less as a loophole and more as the basis with the highest burden of justification.</p><h3>Why Should Interns Care?</h3><p>This was probably my biggest realization.</p><p>As interns, we’re often focused on writing code, fixing issues, and completing our assigned tasks.</p><p>It’s easy to assume that privacy and security are someone else’s responsibility.</p><p>But the reality is that even an intern may work with customer information, logs, support tickets, API requests, or database records that contain personal data.</p><p>That means we also have a responsibility to handle that information carefully.</p><h3>AI Changed the Conversation</h3><p>One thing that became especially relevant recently is the use of AI coding assistants.</p><p>AI can be incredibly helpful for debugging, explaining code, and increasing productivity.</p><p>But before sharing anything with an AI assistant, it’s worth asking:</p><p><strong>“Am I exposing customer data?”</strong></p><p>For example, before sharing:</p><ul><li>Email addresses</li><li>Phone numbers</li><li>Customer names</li><li>Addresses</li><li>API keys</li><li>Access tokens</li><li>Database records</li></ul><p>those values should be removed, masked, or replaced with dummy data whenever possible.</p><p>Instead of sharing:</p><pre>john.doe@example.com</pre><p>share:</p><pre>user@example.com</pre><p>Instead of:</p><pre>Authorization: Bearer eyJh...</pre><p>share:</p><pre>Authorization: Bearer &lt;REDACTED&gt;</pre><p>This gets trickier with things like stack traces or error logs, which is where I almost tripped up myself. When you’re debugging a production issue, it’s tempting to paste the entire error output into an AI assistant to get a quick explanation. But a stack trace can easily include a full database row, a request payload, or a user object — meaning names, emails, and internal IDs can slip through without you noticing, buried in the middle of technical noise. Now I make a habit of skimming any log or trace for anything that looks like real user data before I paste it anywhere, not just checking the obvious fields.</p><p>The goal is to provide enough technical context without exposing sensitive information.</p><h3>Why We Often Neglect This</h3><p>Looking back, I think many students — including myself — don’t pay much attention to privacy because we spend most of our time building projects with sample data.</p><p>University projects rarely expose us to the responsibility of handling real customer information.</p><p>That changes once you begin working on production systems.</p><p>Suddenly, every log entry, screenshot, AI prompt, database query, and shared file could contain information that belongs to a real person.</p><p>That realization completely changed how I think about software development.</p><h3>Final Thoughts</h3><p>One lesson I’ve learned during my internship is that software engineering isn’t only about solving technical problems.</p><p>It’s also about earning and protecting users’ trust.</p><p>Learning frameworks and programming languages is important.</p><p>But learning how to responsibly handle the data entrusted to us is just as important.</p><p>I’m still learning, but if there’s one takeaway I’d like to share with other students and interns, it’s this:</p><p><strong>Before sharing any data, ask yourself one simple question: <em>“Would I be comfortable if this information belonged to me?”</em></strong></p><p>That small habit can make a big difference.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9bf0eab56e80" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Day You Leave a Project Is the Day Documentation Becomes Valuable]]></title>
            <link>https://medium.com/@delaksan/the-day-you-leave-a-project-is-the-day-documentation-becomes-valuable-0818f78f527d?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/0818f78f527d</guid>
            <category><![CDATA[internships]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[documentation]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[technical-documentation]]></category>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Fri, 24 Jul 2026 13:13:23 GMT</pubDate>
            <atom:updated>2026-07-24T13:13:23.623Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*ATq-MvwEOzUwT2QUPIwfdQ.png" /></figure><h3>It’s your first day on a new project.</h3><p>Your manager tells you: “You’ll be taking over this service.”</p><p>Sounds exciting. Until you open the repository.</p><p>No README. No architecture diagram. No setup guide. No explanation of why certain decisions were made.</p><p>The only person who knew everything about the project has already moved to another team — and even they barely remember how it works.</p><p>Now what?</p><h3>The Illusion Developers Have</h3><p>Many developers think: <em>“I’ll remember how this works.”</em></p><p>You won’t.</p><p>Six months later, you’ll struggle to understand code you wrote yourself. The variable names that made sense in the moment. The workaround you added for a bug you no longer remember. The reason you chose this library over that one.</p><p>Now imagine someone else trying to understand it, with none of the context you had and all of the deadline pressure you didn’t.</p><h3>Documentation Isn’t for Today</h3><p>One of the biggest lessons I’ve learned is that documentation isn’t written for the day you build something. It’s written for:</p><ul><li>the next developer</li><li>your future self</li><li>your teammate</li><li>the intern who joins next month</li><li>the engineer on call at 2 AM</li><li>anyone who needs to understand your work without sitting next to you</li></ul><p>You’re not writing it for the version of you who already understands the system. You’re writing it for the version of someone who doesn’t.</p><h3>A Real Scenario</h3><p>Let’s say you’re assigned to maintain an existing project. The previous developer has already moved on.</p><p>You ask: <em>“How do I run this project locally?”</em> Nobody knows.</p><p>You ask: <em>“What environment variables do I need?”</em> Nobody knows.</p><p>You ask: <em>“Why was this architecture chosen?”</em> Nobody knows.</p><p>Instead of solving business problems, you’re spending days reverse-engineering someone else’s work. Not because the project is complicated. Because the knowledge disappeared with the developer.</p><p>Now imagine the opposite. The project contains:</p><ul><li>A README</li><li>Setup instructions</li><li>Architecture overview</li><li>API documentation</li><li>Deployment steps</li><li>Common troubleshooting tips</li><li>Design decisions and their tradeoffs</li></ul><p>Instead of spending days figuring out where to start, a new developer can become productive in hours. Good documentation doesn’t remove every question — it removes the unnecessary ones, so the questions that remain are the interesting ones.</p><h3>Documentation Helps AI Too</h3><p>Today, many developers use AI coding assistants. But an assistant only performs as well as the context it’s given.</p><p>Ask an AI to fix a bug in an undocumented codebase and it will guess. It’ll infer intent from variable names, pattern-match against similar projects it’s seen before, and confidently produce something that <em>looks</em> right but ignores the actual reason your system was built the way it was. It might “fix” a workaround that exists for a reason nobody wrote down.</p><p>Ask the same question with a README, an architecture note, and a short explanation of your conventions in front of it, and the answer changes shape entirely. It stops guessing at your intent and starts working from it. The suggestions match how your team actually builds things, not how a generic project might.</p><p>Documentation doesn’t just help humans anymore. It’s the difference between an AI assistant working <em>with</em> your codebase and one working <em>against</em> its own assumptions about it. Every hour you spend documenting is context you only have to give once — instead of re-explaining it to every new hire, every teammate, and every AI session from now on.</p><p>A project’s biggest risk isn’t outdated code. It’s undocumented knowledge.</p><p>Code can be read. Knowledge disappears the moment the person carrying it walks out the door.</p><p>The next time you finish building a feature, ask yourself one question:</p><p><strong>If I left this project tomorrow, could someone continue my work without needing me?</strong></p><p>If the answer is no, it’s not just your documentation that’s unfinished. It’s your handoff.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0818f78f527d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Production Engineering Lessons They Don’t Teach at University]]></title>
            <link>https://medium.com/@delaksan/production-engineering-lessons-they-dont-teach-at-university-525ef0168d38?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/525ef0168d38</guid>
            <category><![CDATA[lessons-learned]]></category>
            <category><![CDATA[projects]]></category>
            <category><![CDATA[production]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 16:04:01 GMT</pubDate>
            <atom:updated>2026-07-21T16:04:01.098Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*Nk48s2cQlsmsu0NnZB0rOQ.png" /></figure><h3>What nobody tells you about the gap between a CV project and a real production system</h3><p>There is a very specific kind of panic that only exists in the software industry. It is the feeling you get when someone in your team says “we are deploying this on Friday afternoon.” If you have felt your stomach drop at that sentence, you already understand more about production engineering than most computer science degrees ever taught you.</p><p>I remember the exact moment I understood the difference between building software and running software. It was not in a classroom. It was not even during an internship interview prep session where I was polishing my GitHub profile to look like I had been shipping enterprise systems since I was twelve. It was the first time something I built actually broke, in front of actual users, while I was actually asleep.</p><p>University teaches you how to write code that works. Nobody sits you down and teaches you what happens after it works. This article is about that gap, the one between the version of you that builds a project to get hired, and the version of you that has to keep something alive once it is live.</p><h3>The CV Project Theatre</h3><p>Let’s be honest about something first, because I think every developer reading this has lived through it.</p><p>When internship season rolls around, we suddenly remember that project management tools exist. We open Jira or ClickUp for the first time in months and create a beautifully organized board with columns like To Do, In Progress, and Done, populated entirely by us, for us, reviewed by nobody but us. We open Figma and design one clean mockup, not because we needed it, but because we know someone might ask “did you design this before building it.” We suddenly care deeply about commit message conventions and branch naming strategies, and we make absolutely sure our environment files are not sitting in the repository for the world to see.</p><p>None of this is dishonest. It is a performance of good practice, and honestly, performing good practice is how most of us first learn to actually practice it. But there is a quiet truth underneath all of it. On our personal projects, when nobody is watching, we skip most of this. We commit straight to main. We do not write a single ticket. We definitely do not design in Figma before we start coding, unless it is a group project and someone in the group is genuinely passionate about it and drags the rest of us along.</p><p>Production does not care about any of that theatre. Production does not care how organized your Jira board looked in the screenshot you put in your portfolio. Production is a different game entirely, and the rules are written in incidents, not in interviews.</p><h3>The Mindset Shift Nobody Warns You About</h3><p>The first and biggest lesson is not technical at all. It is a mindset.</p><p>At university, and even in most personal projects, success means “it works.” You run it, it does what it is supposed to do, you submit it, you move on. In production, “it works right now” is barely the starting line. The real question becomes will it still work in six months, will it still work when ten times more people use it, will it still work when someone on the team who did not build it has to fix it at 2 AM.</p><p>This is why experienced engineers develop what almost feels like paranoia. Not because they are anxious people, but because they have learned that anything can go wrong, and usually does, eventually. You stop asking “does this work” and start asking “what happens when this stops working.” That single shift in thinking is probably the most valuable thing production teaches you that a lecture hall never will.</p><p>And yes, the Friday deployment fear is real. It is not a joke engineers tell to sound dramatic. If something breaks on a Friday evening, you are not spending your weekend the way you planned. You are staring at logs while your friends are out having dinner.</p><h3>Reliability Is Not a Feature You Add Later</h3><p>In a university project, if something breaks, you fix it, resubmit, and get your grade. There is no concept of “this needs to survive contact with reality.”</p><p>In production, reliability is not something you sprinkle on top once the feature is done. It has to be part of how you design the thing from the very first decision. Yes, quick fixes happen in production all the time. Something breaks, you patch it, you stop the bleeding, you move on to a proper fix later. That is normal and it is fine. What is not fine is treating that emergency mindset as your default design philosophy. A quick fix under pressure is a survival tool. It is not a blueprint for how you should be building new features when you have the time to do it properly.</p><p>Real reliability means thinking about failure before it happens. What happens if this API call times out. What happens if the database connection drops for thirty seconds. What happens if two users hit this exact function at the exact same millisecond. Nobody asks you these questions in a university assignment. Production asks you these questions every single day, whether you are ready for them or not.</p><h3>Monitoring and Logging: The Two Things You Ignore Until You Desperately Need Them</h3><p>Here is something almost every self taught or university trained developer learns the hard way. You never think about monitoring or logging until the exact moment you need them and realize they are not there.</p><p>Monitoring is how you find out something is wrong before your users tell you. In a personal project, your monitoring system is basically your users complaining, or you personally noticing something looks off. In production, that is unacceptable. Teams build dashboards, alerts, and health checks so that problems get caught within minutes, not days. The goal is to know about the fire before the building starts smelling like smoke to everyone else.</p><p>Logging is the quieter hero of this story. When something goes wrong in production, logs are often the only witness to what actually happened. A good log line at 3 AM can save you hours of guessing. It genuinely feels like a life saver when you are staring at a broken system and the logs calmly tell you exactly which line failed and why.</p><p>But here is the part nobody warns you about. Sometimes the logs are not there. Maybe nobody thought to log that particular part of the system. Maybe the log got swallowed somewhere in the pipeline. In those moments, you have to become a detective, reconstructing what happened purely from the outputs and side effects you can observe. This is a skill you only build by living through the frustration of not having the information you needed, and promising yourself you will log better next time.</p><h3>Documentation Is a Love Letter to the Next Person</h3><p>In university, documentation is usually an afterthought, a README you write in the last twenty minutes before the deadline just so it does not look empty. In production, documentation is not optional decoration. It is how knowledge survives beyond any single person.</p><p>Good documentation means that when you leave, get sick, change teams, or simply forget how your own code works six months later, someone else can pick it up and understand the full context without having to message you at midnight. And here is the detail that took me a while to appreciate. Good documentation is not just for other engineers. It should be written clearly enough that a non technical stakeholder, a manager, or a new hire from a completely different background can understand what the system does and why certain decisions were made. If only the person who wrote it can understand it, it is not documentation. It is a private diary.</p><h3>Security Is Not Something You Bolt On at the End</h3><p>Security in a university project usually means “did you hash the password.” In production, security is a mindset that runs through every decision you make, not a checklist you run through once before submission.</p><p>It means thinking about what happens if someone sends malicious input instead of the input you expected. It means not trusting anything that comes from outside your system, including your own frontend. It means being paranoid about what data you expose, what permissions you grant, and what secrets you accidentally leave lying around in a config file or, worse, a public repository. Vulnerable code in a class project gets you a slightly lower grade. Vulnerable code in production can get real people’s real data stolen. That difference changes how seriously you take every single line you write.</p><h3>Scalability: Building for the Users You Do Not Have Yet</h3><p>Nobody in university asks you to imagine what your app looks like with a hundred thousand concurrent users, because nobody in university expects your app to ever have them. In production, that question is not hypothetical. It is the whole point.</p><p>Scalability means designing your system so that success does not become the thing that kills it. It is a strange kind of problem because the better your product does, the harder this problem becomes. A system that works beautifully for ten users can fall apart completely at ten thousand, not because anyone wrote bad code, but because nobody designed for growth. Thinking about scale early, even a little, is one of those habits that quietly separates people who have only built projects from people who have actually run a product.</p><h3>Code Reviews: Where Your Code Meets Reality</h3><p>In personal projects, nobody reviews your code except maybe future you, wincing at past you’s decisions. In production, code review is not a formality, it is a genuine safety net. Someone else looks at what you built before it goes anywhere near real users, and they catch the things you were too close to the problem to notice yourself.</p><p>This is also where you learn humility. Your code is going to get picked apart, questioned, and sometimes rejected outright, and none of that is personal. It is the system working exactly as intended. The engineers who grow the fastest are usually the ones who stop treating code review as criticism of them and start treating it as free quality assurance from people who genuinely want the product to succeed.</p><h3>CI/CD and Testing: The Safety Net You Cannot See Until It Catches You</h3><p>In university, testing often means running your program a few times and eyeballing the output. In production, testing is systematic, automated, and constant. Continuous integration and continuous deployment pipelines exist so that every change gets tested and validated before it ever reaches a real user, without a human having to manually babysit the process every single time.</p><p>This is the machinery that lets teams ship changes multiple times a day without everyone holding their breath. It is invisible when it works well, which is exactly why it is so easy to underestimate until you have worked somewhere without it, pushing changes manually and praying nothing breaks.</p><h3>Business Requirements and Customer Impact: The Part Nobody Grades You On</h3><p>A university project has one audience, your professor, and one goal, a grade. Production software has a business behind it, and that business has real constraints, real deadlines, and real customers whose day gets disrupted when something breaks.</p><p>Understanding business requirements means realizing that not every technically interesting solution is the right solution. Sometimes the “boring” fix is correct because it ships faster and solves the actual customer problem. Understanding customer impact means realizing that a bug is never just a bug. It is a real person somewhere unable to do something they needed to do, at a moment that mattered to them. That realization changes how urgently you treat problems, and how much empathy you bring into fixing them.</p><h3>Communication: The Skill That Ties Everything Together</h3><p>Every single thing on this list, the monitoring, the documentation, the code reviews, the incident response, eventually comes down to communication. Explaining a bug to a non technical manager. Writing a clear incident report after something breaks. Telling your team honestly that you are stuck instead of quietly struggling for three days. None of this is taught in a lecture on data structures, yet it is often the difference between a good engineer and a great one.</p><h3>So What Do You Actually Do With This</h3><p>If you are still building CV projects to survive internship interviews, keep doing it. There is nothing wrong with learning to speak the language of professional workflows before you are forced to live inside them. But somewhere alongside that performance, try to build one thing for real. Put it in production. Let real, if small, traffic hit it. Let it break. Fix it without a deadline forcing your hand, just because you want to understand what breaking and fixing actually feels like.</p><p>University gives you the vocabulary. Production gives you the scars that make the vocabulary mean something. The gap between the two is not something you close by reading about it. You close it by shipping something, watching it wobble, and staying up late enough to understand exactly why.</p><p>That is the real education. Nobody hands you a certificate for it, but you will know you have earned it the first time you casually mention to a friend that you are not deploying on a Friday, and they immediately, without any explanation needed, understand exactly why.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=525ef0168d38" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Nobody Is Coming to Find You — So Go Find the Opportunity Yourself]]></title>
            <link>https://medium.com/@delaksan/nobody-is-coming-to-find-you-so-go-find-the-opportunity-yourself-664b19ad2265?source=rss-e435821985e9------2</link>
            <guid isPermaLink="false">https://medium.com/p/664b19ad2265</guid>
            <category><![CDATA[speak-up-for-yourself]]></category>
            <category><![CDATA[chasing-dreams]]></category>
            <category><![CDATA[opportunity]]></category>
            <dc:creator><![CDATA[Delaksan Sritharan]]></dc:creator>
            <pubDate>Mon, 22 Jun 2026 15:29:02 GMT</pubDate>
            <atom:updated>2026-06-22T15:29:02.262Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dnVFOD2E3XArrBiSa3mR5w.png" /></figure><p>There’s a belief a lot of people carry quietly: if you’re good enough, people will notice. Keep your head down, do the work, and the right opportunities will find their way to you.</p><p>That’s not how it works.</p><h3>Speak for Yourself — Before Someone Else Defines You</h3><p>Here’s something I’ve learned: you have to ask for things. You have to speak up for yourself. Because no one will ever know what you’re capable of until you show them.</p><p>Most people hold back. They’re afraid that if they talk about what they’re good at, others will think they’re showing off. And maybe some people will. That’s a real possibility, and I won’t pretend otherwise. But here’s the question worth asking: what’s the cost of staying silent?</p><p>You lose the opportunity. Every single time.</p><p>Think about it this way. Your university or company is organizing something — an event, a campaign, a product launch. They need a designer. They need a speaker. They need someone with good people skills. You have all three. But you said nothing. So they searched, they asked around, and they found someone else — all while you were sitting two rooms away, more than capable of doing the job.</p><p>They weren’t ignoring you. They genuinely didn’t know.</p><p>That’s the gap between showcasing yourself and showing off. Showing off is about ego — making yourself seem bigger than you are. Showcasing is simply making sure the right people know what you can do. One is about performance. The other is about access.</p><h3>Opportunities Don’t Fall — You Have to Chase the Door</h3><p>People ask me sometimes: how do you keep getting opportunities?</p><p>The answer is simple, and it’s exactly what I’m doing right now by writing this. I put my work out there. I talk about what I know. I share what I’m learning. And somewhere along the way, that creates a signal — and the right people pick it up.</p><p>It doesn’t have to be a grand gesture. It can be a LinkedIn post. A conversation after class. Volunteering for the task nobody else raised their hand for. The medium doesn’t matter as much as the consistency. If you keep showing up and showing what you can do, opportunities accumulate over time.</p><p>But here’s the harder truth: doors don’t open on their own. They never have. You have to walk toward them, knock, and sometimes push. The people who seem like they always “get lucky” are usually just the ones who keep showing up at the door.</p><p>So chase it. Work for it. Don’t sit back and hope someone notices.</p><h3>Your Connections Are Your Wealth</h3><p>The second piece of this is who you know — and more importantly, who knows you.</p><p>A lot of people misunderstand what networking actually means. They think it’s about collecting names, attending events to look important, or dropping “I know this person” into every conversation. That’s not connection. That’s performance.</p><p>Real connection is quieter than that. It’s a meaningful conversation you had with someone six months ago. It’s the story you told that stuck with them. It’s the genuine interest you showed in what they were building.</p><p>Let me give you a real example. Say you run a tag printing shop. One day, you get talking to a CEO at some casual event — not to pitch, not to impress, just an honest conversation where you mentioned what you do and shared a bit of your story. That conversation felt small at the time.</p><p>Then, three months later, that CEO is organizing an event and needs tags printed. Your name comes up in his memory — not because you followed up five times or handed him a flyer, but because the conversation meant something. Or maybe he’s talking to a friend who mentions the same need, and he says, “actually, I know someone.”</p><p>That referral? That’s the compound interest of genuine connection.</p><p>This is why talking to people matters. Not to show off. Not to name-drop. But because you’re quietly laying the foundation of a network that will work for you long after the conversation ends. Every person you connect with genuinely is a door you didn’t even know existed yet.</p><h3>The Uncomfortable Part</h3><p>None of this is comfortable at first. Putting yourself out there feels exposed. Speaking up in a room where no one asked for your input feels presumptuous. Starting conversations with strangers feels awkward.</p><p>Do it anyway.</p><p>The discomfort fades. The missed opportunities don’t.</p><p>You are good at things. Real things. Things that other people need. But that only matters if they know about it — and they’ll only know about it if you tell them.</p><p>So speak. Write. Show up. Chase the door.</p><p>The opportunity you’re waiting for might already be waiting on the other side.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=664b19ad2265" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>